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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
51,200 | LefDefParser::lefwMacroPinSupplySensitivity(char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwMacroPinSupplySensitivity(const char *pinName)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (!lefwIsMacroPin)
return LEFW_BAD_ORDER;
if (!pinName || pinName == 0 || *pinName == 0)
return LEFW_BAD_DATA;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " SUPPLYSENSITIVITY %s ;\n", pinName);
else
fprintf(lefwFile, " SUPPLYSENSITIVITY %s ;\n", pinName);
lefwLines++;
lefwState = LEFW_MACRO;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwMacroPinSupplySensitivity(char const*):
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x98640(%rip), %rax # 0xc5250
cmpq $0x0, (%rax)
jne 0x2cc23
movl $0x1, 0x14(%rsp)
jmp 0x2cceb
leaq 0x9887a(%rip), %rax # 0xc54a4
cmpl $0x0, (%rax)
jne 0x2cc3c
movl $0x2, 0x14(%rsp)
jmp 0x2cceb
leaq 0x988ad(%rip), %rax # 0xc54f0
cmpl $0x0, (%rax)
jne 0x2cc55
movl $0x2, 0x14(%rsp)
jmp 0x2cceb
cmpq $0x0, 0x8(%rsp)
je 0x2cc72
cmpq $0x0, 0x8(%rsp)
je 0x2cc72
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2cc7c
movl $0x3, 0x14(%rsp)
jmp 0x2cceb
cmpl $0x0, 0x988b9(%rip) # 0xc553c
je 0x2cca4
leaq 0x985c4(%rip), %rax # 0xc5250
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x67324(%rip), %rsi # 0x93fbf
movb $0x0, %al
callq 0x8bf50
jmp 0x2ccc1
leaq 0x985a5(%rip), %rax # 0xc5250
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x67305(%rip), %rsi # 0x93fbf
movb $0x0, %al
callq 0x2370
leaq 0x987d4(%rip), %rax # 0xc549c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x987c8(%rip), %rax # 0xc549c
movl %ecx, (%rax)
leaq 0x987c3(%rip), %rax # 0xc54a0
movl $0x21, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN12LefDefParser29lefwMacroPinSupplySensitivityEPKc:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_2CC23
mov [rsp+18h+var_4], 1
jmp loc_2CCEB
loc_2CC23:
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
jnz short loc_2CC3C
mov [rsp+18h+var_4], 2
jmp loc_2CCEB
loc_2CC3C:
lea rax, _ZN12LefDefParser14lefwIsMacroPinE; LefDefParser::lefwIsMacroPin
cmp dword ptr [rax], 0
jnz short loc_2CC55
mov [rsp+18h+var_4], 2
jmp loc_2CCEB
loc_2CC55:
cmp [rsp+18h+var_10], 0
jz short loc_2CC72
cmp [rsp+18h+var_10], 0
jz short loc_2CC72
mov rax, [rsp+18h+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_2CC7C
loc_2CC72:
mov [rsp+18h+var_4], 3
jmp short loc_2CCEB
loc_2CC7C:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_2CCA4
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
lea rsi, aSupplysensitiv; " SUPPLYSENSITIVITY %s ;\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_2CCC1
loc_2CCA4:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
lea rsi, aSupplysensitiv; " SUPPLYSENSITIVITY %s ;\n"
mov al, 0
call _fprintf
loc_2CCC1:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 21h ; '!'
mov [rsp+18h+var_4], 0
loc_2CCEB:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long LefDefParser::lefwMacroPinSupplySensitivity(
LefDefParser *this,
const char *a2,
long long a3,
int a4,
int a5,
int a6)
{
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwIsMacroPin )
{
if ( this && *(_BYTE *)this )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" SUPPLYSENSITIVITY %s ;\n",
(_DWORD)this,
a4,
a5,
a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " SUPPLYSENSITIVITY %s ;\n", (const char *)this);
++LefDefParser::lefwLines;
LefDefParser::lefwState = 33;
return 0;
}
else
{
return 3;
}
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwMacroPinSupplySensitivity:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
LEA RAX,[0x1c5250]
CMP qword ptr [RAX],0x0
JNZ 0x0012cc23
MOV dword ptr [RSP + 0x14],0x1
JMP 0x0012cceb
LAB_0012cc23:
LEA RAX,[0x1c54a4]
CMP dword ptr [RAX],0x0
JNZ 0x0012cc3c
MOV dword ptr [RSP + 0x14],0x2
JMP 0x0012cceb
LAB_0012cc3c:
LEA RAX,[0x1c54f0]
CMP dword ptr [RAX],0x0
JNZ 0x0012cc55
MOV dword ptr [RSP + 0x14],0x2
JMP 0x0012cceb
LAB_0012cc55:
CMP qword ptr [RSP + 0x8],0x0
JZ 0x0012cc72
CMP qword ptr [RSP + 0x8],0x0
JZ 0x0012cc72
MOV RAX,qword ptr [RSP + 0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x0012cc7c
LAB_0012cc72:
MOV dword ptr [RSP + 0x14],0x3
JMP 0x0012cceb
LAB_0012cc7c:
CMP dword ptr [0x001c553c],0x0
JZ 0x0012cca4
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[0x193fbf]
MOV AL,0x0
CALL 0x0018bf50
JMP 0x0012ccc1
LAB_0012cca4:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[0x193fbf]
MOV AL,0x0
CALL 0x00102370
LAB_0012ccc1:
LEA RAX,[0x1c549c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x1c549c]
MOV dword ptr [RAX],ECX
LEA RAX,[0x1c54a0]
MOV dword ptr [RAX],0x21
MOV dword ptr [RSP + 0x14],0x0
LAB_0012cceb:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwMacroPinSupplySensitivity(char const*) */
int4 LefDefParser::lefwMacroPinSupplySensitivity(char *param_1)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if (lefwDidInit == 0) {
local_4 = 2;
}
else if (lefwIsMacroPin == 0) {
local_4 = 2;
}
else if (((param_1 == (char *)0x0) || (param_1 == (char *)0x0)) || (*param_1 == '\0')) {
local_4 = 3;
}
else {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," SUPPLYSENSITIVITY %s ;\n",param_1);
}
else {
encPrint(lefwFile," SUPPLYSENSITIVITY %s ;\n",param_1);
}
lefwLines = lefwLines + 1;
lefwState = 0x21;
local_4 = 0;
}
return local_4;
}
| |
51,201 | JS_ToBigInt64Free | bluesky950520[P]quickjs/quickjs.c | static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val)
{
bf_t a_s, *a;
a = JS_ToBigIntFree(ctx, &a_s, val);
if (!a) {
*pres = 0;
return -1;
}
bf_get_int64(pres, a, BF_GET_INT_MOD);
JS_FreeBigInt(ctx, a, &a_s);
return 0;
} | O2 | c | JS_ToBigInt64Free:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x3a61e
testq %rax, %rax
je 0x25a4c
movq %rax, %r15
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x76253
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a605
xorl %eax, %eax
jmp 0x25a53
andq $0x0, (%r14)
pushq $-0x1
popq %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
| JS_ToBigInt64Free:
push r15
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
lea rsi, [rsp+48h+var_40]
call JS_ToBigIntFree
test rax, rax
jz short loc_25A4C
mov r15, rax
push 1
pop rdx
mov rdi, r14
mov rsi, rax
call bf_get_int64
lea rdx, [rsp+48h+var_40]
mov rdi, rbx
mov rsi, r15
call JS_FreeBigInt
xor eax, eax
jmp short loc_25A53
loc_25A4C:
and qword ptr [r14], 0
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_25A53:
add rsp, 30h
pop rbx
pop r14
pop r15
retn
| long long JS_ToBigInt64Free(long long a1, _QWORD *a2)
{
long long v2; // rax
long long v3; // r15
_BYTE v5[64]; // [rsp+8h] [rbp-40h] BYREF
v2 = JS_ToBigIntFree(a1, v5);
if ( v2 )
{
v3 = v2;
bf_get_int64(a2, v2, 1LL);
JS_FreeBigInt(a1, v3, v5);
return 0LL;
}
else
{
*a2 = 0LL;
return -1LL;
}
}
| JS_ToBigInt64Free:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x8]
CALL 0x0013a61e
TEST RAX,RAX
JZ 0x00125a4c
MOV R15,RAX
PUSH 0x1
POP RDX
MOV RDI,R14
MOV RSI,RAX
CALL 0x00176253
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV RSI,R15
CALL 0x0013a605
XOR EAX,EAX
JMP 0x00125a53
LAB_00125a4c:
AND qword ptr [R14],0x0
PUSH -0x1
POP RAX
LAB_00125a53:
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
int8 JS_ToBigInt64Free(int8 param_1,int8 *param_2)
{
long lVar1;
int8 uVar2;
int1 local_40 [40];
lVar1 = JS_ToBigIntFree(param_1,local_40);
if (lVar1 == 0) {
*param_2 = 0;
uVar2 = 0xffffffffffffffff;
}
else {
bf_get_int64(param_2,lVar1,1);
JS_FreeBigInt(param_1,lVar1,local_40);
uVar2 = 0;
}
return uVar2;
}
| |
51,202 | mi_ft_convert_to_ft2 | eloqsql/storage/myisam/ft_update.c | uint _mi_ft_convert_to_ft2(MI_INFO *info, uint keynr, uchar *key)
{
my_off_t root;
DYNAMIC_ARRAY *da=info->ft1_to_ft2;
MI_KEYDEF *keyinfo=&info->s->ft2_keyinfo;
uchar *key_ptr= (uchar*) dynamic_array_ptr(da, 0), *end;
uint length, key_length;
DBUG_ENTER("_mi_ft_convert_to_ft2");
/* we'll generate one pageful at once, and insert the rest one-by-one */
/* calculating the length of this page ...*/
length=(keyinfo->block_length-2) / keyinfo->keylength;
set_if_smaller(length, da->elements);
length=length * keyinfo->keylength;
get_key_full_length_rdonly(key_length, key);
while (_mi_ck_delete(info, keynr, key, key_length) == 0)
{
/*
nothing to do here.
_mi_ck_delete() will populate info->ft1_to_ft2 with deleted keys
*/
}
/* creating pageful of keys */
mi_putint(info->buff,length+2,0);
memcpy(info->buff+2, key_ptr, length);
info->buff_used=info->page_changed=1; /* info->buff is used */
if ((root= _mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR ||
_mi_write_keypage(info,keyinfo,root,DFLT_INIT_HITS,info->buff))
DBUG_RETURN(-1);
/* inserting the rest of key values */
end= (uchar*) dynamic_array_ptr(da, da->elements);
for (key_ptr+=length; key_ptr < end; key_ptr+=keyinfo->keylength)
if(_mi_ck_real_write_btree(info, keyinfo, key_ptr, 0, &root, SEARCH_SAME))
DBUG_RETURN(-1);
/* now, writing the word key entry */
ft_intXstore(key+key_length, - (int) da->elements);
_mi_dpointer(info, key+key_length+HA_FT_WLEN, root);
DBUG_RETURN(_mi_ck_real_write_btree(info,
info->s->keyinfo+keynr,
key, 0,
&info->s->state.key_root[keynr],
SEARCH_SAME));
} | O3 | c | mi_ft_convert_to_ft2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %rcx
movq 0x88(%rdi), %rsi
movzwl 0x1b6(%rcx), %eax
addl $-0x2, %eax
movq %rcx, -0x48(%rbp)
movzwl 0x1ba(%rcx), %ecx
cltd
idivl %ecx
movl 0x8(%rsi), %edx
cmpl %edx, %eax
cmovbl %eax, %edx
movzbl (%rbx), %r12d
cmpl $0xff, %r12d
je 0x75e7d
incl %r12d
jmp 0x75e8d
movzwl 0x1(%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %r12d
addl $0x3, %r12d
movq -0x48(%rbp), %rax
addq $0x1a8, %rax # imm = 0x1A8
movq %rax, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq (%rsi), %r13
imull %ecx, %edx
movq %rdx, -0x30(%rbp)
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movl %r12d, %ecx
callq 0x7630d
testl %eax, %eax
je 0x75ea9
movq -0x30(%rbp), %rdx
leal 0x2(%rdx), %eax
movq 0x100(%r14), %rcx
movb %al, 0x1(%rcx)
movq 0x100(%r14), %rcx
movb %ah, (%rcx)
movq 0x100(%r14), %rdi
addq $0x2, %rdi
movl %edx, %edx
movq %r13, %rsi
movq %rdx, -0x30(%rbp)
callq 0x2a0a0
movw $0x101, 0x33c(%r14) # imm = 0x101
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movl $0x3, %edx
callq 0x85532
movq %rax, %rcx
movq %rax, -0x50(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq $-0x1, %rcx
je 0x75ff7
movq 0x100(%r14), %r8
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq %rcx, -0x58(%rbp)
movq %rcx, %rdx
movl $0x3, %ecx
callq 0x85380
testl %eax, %eax
je 0x75f4f
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x75ff7
movq -0x58(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl 0x8(%rcx), %eax
movl 0x14(%rcx), %esi
imull %eax, %esi
addq (%rcx), %rsi
addq -0x30(%rbp), %r13
movq %rsi, -0x30(%rbp)
cmpq %rsi, %r13
jae 0x75fae
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq %r13, %rdx
xorl %ecx, %ecx
leaq -0x50(%rbp), %r8
movl $0x4, %r9d
callq 0x8997b
testl %eax, %eax
jne 0x75f45
movq -0x48(%rbp), %rax
movzwl 0x1ba(%rax), %eax
addq %rax, %r13
cmpq -0x30(%rbp), %r13
jb 0x75f70
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x50(%rbp), %rdx
negl %eax
movl %r12d, %ecx
bswapl %eax
leaq (%rbx,%rcx), %rsi
addq $0x4, %rsi
movl %eax, -0x4(%rsi)
movq %r14, %rdi
callq 0x869f3
movq (%r14), %rax
movl %r15d, %r8d
imulq $0x70, %r8, %rsi
addq 0x218(%rax), %rsi
shlq $0x3, %r8
addq 0x98(%rax), %r8
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
movl $0x4, %r9d
callq 0x8997b
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _mi_ft_convert_to_ft2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rdx
mov r15d, esi
mov r14, rdi
mov rcx, [rdi]
mov rsi, [rdi+88h]
movzx eax, word ptr [rcx+1B6h]
add eax, 0FFFFFFFEh
mov [rbp+var_48], rcx
movzx ecx, word ptr [rcx+1BAh]
cdq
idiv ecx
mov edx, [rsi+8]
cmp eax, edx
cmovb edx, eax
movzx r12d, byte ptr [rbx]
cmp r12d, 0FFh
jz short loc_75E7D
inc r12d
jmp short loc_75E8D
loc_75E7D:
movzx eax, word ptr [rbx+1]
rol ax, 8
movzx r12d, ax
add r12d, 3
loc_75E8D:
mov rax, [rbp+var_48]
add rax, 1A8h
mov [rbp+var_38], rax
mov [rbp+var_40], rsi
mov r13, [rsi]
imul edx, ecx
mov [rbp+var_30], rdx
loc_75EA9:
mov rdi, r14
mov esi, r15d
mov rdx, rbx
mov ecx, r12d
call _mi_ck_delete
test eax, eax
jz short loc_75EA9
mov rdx, [rbp+var_30]
lea eax, [rdx+2]
mov rcx, [r14+100h]
mov [rcx+1], al
mov rcx, [r14+100h]
mov [rcx], ah
mov rdi, [r14+100h]
add rdi, 2
mov edx, edx
mov rsi, r13
mov [rbp+var_30], rdx
call _memcpy
mov word ptr [r14+33Ch], 101h
mov rdi, r14
mov rsi, [rbp+var_38]
mov edx, 3
call _mi_new
mov rcx, rax
mov [rbp+var_50], rax
mov eax, 0FFFFFFFFh
cmp rcx, 0FFFFFFFFFFFFFFFFh
jz loc_75FF7
mov r8, [r14+100h]
mov rdi, r14
mov rsi, [rbp+var_38]
mov [rbp+var_58], rcx
mov rdx, rcx
mov ecx, 3
call _mi_write_keypage
test eax, eax
jz short loc_75F4F
loc_75F45:
mov eax, 0FFFFFFFFh
jmp loc_75FF7
loc_75F4F:
mov rdx, [rbp+var_58]
mov rcx, [rbp+var_40]
mov eax, [rcx+8]
mov esi, [rcx+14h]
imul esi, eax
add rsi, [rcx]
add r13, [rbp+var_30]
mov [rbp+var_30], rsi
cmp r13, rsi
jnb short loc_75FAE
loc_75F70:
mov rdi, r14
mov rsi, [rbp+var_38]
mov rdx, r13
xor ecx, ecx
lea r8, [rbp+var_50]
mov r9d, 4
call _mi_ck_real_write_btree
test eax, eax
jnz short loc_75F45
mov rax, [rbp+var_48]
movzx eax, word ptr [rax+1BAh]
add r13, rax
cmp r13, [rbp+var_30]
jb short loc_75F70
mov rax, [rbp+var_40]
mov eax, [rax+8]
mov rdx, [rbp+var_50]
loc_75FAE:
neg eax
mov ecx, r12d
bswap eax
lea rsi, [rbx+rcx]
add rsi, 4
mov [rsi-4], eax
mov rdi, r14
call _mi_dpointer
mov rax, [r14]
mov r8d, r15d
imul rsi, r8, 70h ; 'p'
add rsi, [rax+218h]
shl r8, 3
add r8, [rax+98h]
mov rdi, r14
mov rdx, rbx
xor ecx, ecx
mov r9d, 4
call _mi_ck_real_write_btree
loc_75FF7:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_ft_convert_to_ft2(long long *a1, unsigned int a2, unsigned __int8 *a3)
{
long long *v6; // rsi
int v7; // eax
int v8; // ecx
unsigned int v9; // eax
unsigned int v10; // edx
int v11; // r12d
unsigned int v12; // r12d
long long v13; // r13
unsigned int v14; // edx
__int16 v15; // ax
long long v16; // rdi
long long v17; // rcx
long long result; // rax
long long v19; // r8
long long v20; // rdx
int v21; // eax
unsigned long long v22; // r13
long long v23; // rsi
long long v24; // [rsp+8h] [rbp-58h]
long long v25; // [rsp+10h] [rbp-50h] BYREF
long long v26; // [rsp+18h] [rbp-48h]
long long *v27; // [rsp+20h] [rbp-40h]
long long v28; // [rsp+28h] [rbp-38h]
unsigned long long v29; // [rsp+30h] [rbp-30h]
v6 = (long long *)a1[17];
v7 = *(unsigned __int16 *)(*a1 + 438) - 2;
v26 = *a1;
v8 = *(unsigned __int16 *)(v26 + 442);
v9 = v7 / v8;
v10 = *((_DWORD *)v6 + 2);
if ( v9 < v10 )
v10 = v9;
v11 = *a3;
if ( v11 == 255 )
v12 = (unsigned __int16)__ROL2__(*(_WORD *)(a3 + 1), 8) + 3;
else
v12 = v11 + 1;
v28 = v26 + 424;
v27 = v6;
v13 = *v6;
v29 = v8 * v10;
while ( !(unsigned int)mi_ck_delete(a1, a2, a3, v12) )
;
v14 = v29;
v15 = v29 + 2;
*(_BYTE *)(a1[32] + 1) = v29 + 2;
*(_BYTE *)a1[32] = HIBYTE(v15);
v16 = a1[32] + 2;
v29 = v14;
memcpy(v16, v13, v14);
*((_WORD *)a1 + 414) = 257;
v17 = mi_new(a1, v28, 3LL);
v25 = v17;
result = 0xFFFFFFFFLL;
if ( v17 != -1 )
{
v24 = v17;
if ( (unsigned int)mi_write_keypage(a1, v28, v17, 3LL, a1[32]) )
return 0xFFFFFFFFLL;
v20 = v24;
v21 = *((_DWORD *)v27 + 2);
v22 = v29 + v13;
v29 = *v27 + (unsigned int)(v21 * *((_DWORD *)v27 + 5));
if ( v22 < v29 )
{
while ( !(unsigned int)mi_ck_real_write_btree(a1, v28, v22, 0LL, &v25, 4LL) )
{
v22 += *(unsigned __int16 *)(v26 + 442);
if ( v22 >= v29 )
{
v21 = *((_DWORD *)v27 + 2);
v20 = v25;
goto LABEL_15;
}
}
return 0xFFFFFFFFLL;
}
LABEL_15:
v23 = (long long)&a3[v12 + 4];
*(_DWORD *)(v23 - 4) = _byteswap_ulong(-v21);
mi_dpointer(a1, v23, v20, v12, v19);
return mi_ck_real_write_btree(
a1,
*(_QWORD *)(*a1 + 536) + 112LL * a2,
a3,
0LL,
*(_QWORD *)(*a1 + 152) + 8LL * a2,
4LL);
}
return result;
}
| _mi_ft_convert_to_ft2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDX
MOV R15D,ESI
MOV R14,RDI
MOV RCX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x88]
MOVZX EAX,word ptr [RCX + 0x1b6]
ADD EAX,-0x2
MOV qword ptr [RBP + -0x48],RCX
MOVZX ECX,word ptr [RCX + 0x1ba]
CDQ
IDIV ECX
MOV EDX,dword ptr [RSI + 0x8]
CMP EAX,EDX
CMOVC EDX,EAX
MOVZX R12D,byte ptr [RBX]
CMP R12D,0xff
JZ 0x00175e7d
INC R12D
JMP 0x00175e8d
LAB_00175e7d:
MOVZX EAX,word ptr [RBX + 0x1]
ROL AX,0x8
MOVZX R12D,AX
ADD R12D,0x3
LAB_00175e8d:
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1a8
MOV qword ptr [RBP + -0x38],RAX
MOV qword ptr [RBP + -0x40],RSI
MOV R13,qword ptr [RSI]
IMUL EDX,ECX
MOV qword ptr [RBP + -0x30],RDX
LAB_00175ea9:
MOV RDI,R14
MOV ESI,R15D
MOV RDX,RBX
MOV ECX,R12D
CALL 0x0017630d
TEST EAX,EAX
JZ 0x00175ea9
MOV RDX,qword ptr [RBP + -0x30]
LEA EAX,[RDX + 0x2]
MOV RCX,qword ptr [R14 + 0x100]
MOV byte ptr [RCX + 0x1],AL
MOV RCX,qword ptr [R14 + 0x100]
MOV byte ptr [RCX],AH
MOV RDI,qword ptr [R14 + 0x100]
ADD RDI,0x2
MOV EDX,EDX
MOV RSI,R13
MOV qword ptr [RBP + -0x30],RDX
CALL 0x0012a0a0
MOV word ptr [R14 + 0x33c],0x101
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,0x3
CALL 0x00185532
MOV RCX,RAX
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,0xffffffff
CMP RCX,-0x1
JZ 0x00175ff7
MOV R8,qword ptr [R14 + 0x100]
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x58],RCX
MOV RDX,RCX
MOV ECX,0x3
CALL 0x00185380
TEST EAX,EAX
JZ 0x00175f4f
LAB_00175f45:
MOV EAX,0xffffffff
JMP 0x00175ff7
LAB_00175f4f:
MOV RDX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RCX + 0x8]
MOV ESI,dword ptr [RCX + 0x14]
IMUL ESI,EAX
ADD RSI,qword ptr [RCX]
ADD R13,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RSI
CMP R13,RSI
JNC 0x00175fae
LAB_00175f70:
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,R13
XOR ECX,ECX
LEA R8,[RBP + -0x50]
MOV R9D,0x4
CALL 0x0018997b
TEST EAX,EAX
JNZ 0x00175f45
MOV RAX,qword ptr [RBP + -0x48]
MOVZX EAX,word ptr [RAX + 0x1ba]
ADD R13,RAX
CMP R13,qword ptr [RBP + -0x30]
JC 0x00175f70
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x8]
MOV RDX,qword ptr [RBP + -0x50]
LAB_00175fae:
NEG EAX
MOV ECX,R12D
BSWAP EAX
LEA RSI,[RBX + RCX*0x1]
ADD RSI,0x4
MOV dword ptr [RSI + -0x4],EAX
MOV RDI,R14
CALL 0x001869f3
MOV RAX,qword ptr [R14]
MOV R8D,R15D
IMUL RSI,R8,0x70
ADD RSI,qword ptr [RAX + 0x218]
SHL R8,0x3
ADD R8,qword ptr [RAX + 0x98]
MOV RDI,R14
MOV RDX,RBX
XOR ECX,ECX
MOV R9D,0x4
CALL 0x0018997b
LAB_00175ff7:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 _mi_ft_convert_to_ft2(long *param_1,uint param_2,byte *param_3)
{
void *__src;
uint uVar1;
int iVar2;
uint uVar3;
long lVar4;
int8 uVar5;
ulong uVar6;
ulong uVar7;
long local_58;
long local_50;
long *local_48;
long local_40;
ulong local_38;
local_50 = *param_1;
local_48 = (long *)param_1[0x11];
uVar1 = (int)(*(ushort *)(local_50 + 0x1b6) - 2) / (int)(uint)*(ushort *)(local_50 + 0x1ba);
uVar3 = *(uint *)(local_48 + 1);
if (uVar1 < *(uint *)(local_48 + 1)) {
uVar3 = uVar1;
}
if (*param_3 == 0xff) {
uVar1 = (ushort)(*(ushort *)(param_3 + 1) << 8 | *(ushort *)(param_3 + 1) >> 8) + 3;
}
else {
uVar1 = *param_3 + 1;
}
local_40 = local_50 + 0x1a8;
__src = (void *)*local_48;
local_38 = (ulong)(uVar3 * *(ushort *)(local_50 + 0x1ba));
do {
iVar2 = _mi_ck_delete(param_1,param_2,param_3,uVar1);
} while (iVar2 == 0);
iVar2 = (int)local_38 + 2;
*(char *)(param_1[0x20] + 1) = (char)iVar2;
*(char *)param_1[0x20] = (char)((uint)iVar2 >> 8);
local_38 = local_38 & 0xffffffff;
memcpy((void *)(param_1[0x20] + 2),__src,local_38);
*(int2 *)((long)param_1 + 0x33c) = 0x101;
lVar4 = _mi_new(param_1,local_40,3);
uVar5 = 0xffffffff;
if (lVar4 != -1) {
local_58 = lVar4;
iVar2 = _mi_write_keypage(param_1,local_40,lVar4,3,param_1[0x20]);
if (iVar2 == 0) {
iVar2 = (int)local_48[1];
uVar6 = (ulong)(uint)(*(int *)((long)local_48 + 0x14) * iVar2) + *local_48;
uVar7 = (long)__src + local_38;
local_38 = uVar6;
if (uVar7 < uVar6) {
do {
iVar2 = _mi_ck_real_write_btree(param_1,local_40,uVar7,0,&local_58,4);
if (iVar2 != 0) goto LAB_00175f45;
uVar7 = uVar7 + *(ushort *)(local_50 + 0x1ba);
} while (uVar7 < local_38);
iVar2 = (int)local_48[1];
lVar4 = local_58;
}
uVar3 = -iVar2;
*(uint *)(param_3 + uVar1) =
uVar3 >> 0x18 | (uVar3 & 0xff0000) >> 8 | (uVar3 & 0xff00) << 8 | iVar2 * -0x1000000;
_mi_dpointer(param_1,(uint *)((long)(param_3 + uVar1) + 4),lVar4);
uVar5 = _mi_ck_real_write_btree
(param_1,(ulong)param_2 * 0x70 + *(long *)(*param_1 + 0x218),param_3,0,
(ulong)param_2 * 8 + *(long *)(*param_1 + 0x98),4);
}
else {
LAB_00175f45:
uVar5 = 0xffffffff;
}
}
return uVar5;
}
| |
51,203 | LefDefParser::lefiSite::addRowPattern(char const*, int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMisc.cpp | void
lefiSite::addRowPattern(const char *name,
int orient)
{
if (numRowPattern_ == rowPatternAllocated_) {
int i;
char **sn;
int *so;
rowPatternAllocated_ = (rowPatternAllocated_ == 0) ? 2 :
rowPatternAllocated_ * 2;
sn = (char**) lefMalloc(sizeof(char*) * rowPatternAllocated_);
so = (int*) lefMalloc(sizeof(int) * rowPatternAllocated_);
for (i = 0; i < numRowPattern_; i++) {
sn[i] = siteNames_[i];
so[i] = siteOrients_[i];
}
if (siteNames_) {
lefFree((char*) (siteNames_));
lefFree((char*) (siteOrients_));
}
siteNames_ = sn;
siteOrients_ = so;
}
siteNames_[numRowPattern_] = strdup(name);
siteOrients_[numRowPattern_] = orient;
numRowPattern_ += 1;
} | O3 | cpp | LefDefParser::lefiSite::addRowPattern(char const*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x38(%rdi), %ebp
cmpl 0x3c(%rdi), %ebp
jne 0x12944
leal (,%rbp,2), %eax
testl %ebp, %ebp
movl $0x2, %ecx
cmovnel %eax, %ecx
movl %ecx, 0x3c(%r14)
movslq %ecx, %rdi
shlq $0x3, %rdi
callq 0x24985
movq %rax, %r12
movslq 0x3c(%r14), %rdi
shlq $0x2, %rdi
callq 0x24985
movq %rax, %r13
movl 0x38(%r14), %ebp
testl %ebp, %ebp
jle 0x1291f
xorl %eax, %eax
movq 0x40(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, (%r12,%rax,8)
movq 0x48(%r14), %rcx
movl (%rcx,%rax,4), %ecx
movl %ecx, (%r13,%rax,4)
incq %rax
movslq 0x38(%r14), %rbp
cmpq %rbp, %rax
jl 0x128fb
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x1293a
callq 0x26040
movq 0x48(%r14), %rdi
callq 0x26040
movl 0x38(%r14), %ebp
movq %r12, 0x40(%r14)
movq %r13, 0x48(%r14)
jmp 0x12948
movq 0x40(%r14), %r12
movq %r15, %rdi
callq 0x2380
movslq %ebp, %rcx
movq %rax, (%r12,%rcx,8)
movq 0x48(%r14), %rax
movl %ebx, (%rax,%rcx,4)
incl 0x38(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN12LefDefParser8lefiSite13addRowPatternEPKci:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, edx
mov r15, rsi
mov r14, rdi
mov ebp, [rdi+38h]
cmp ebp, [rdi+3Ch]
jnz loc_12944
lea eax, ds:0[rbp*2]
test ebp, ebp
mov ecx, 2
cmovnz ecx, eax
mov [r14+3Ch], ecx
movsxd rdi, ecx
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r12, rax
movsxd rdi, dword ptr [r14+3Ch]
shl rdi, 2; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r13, rax
mov ebp, [r14+38h]
test ebp, ebp
jle short loc_1291F
xor eax, eax
loc_128FB:
mov rcx, [r14+40h]
mov rcx, [rcx+rax*8]
mov [r12+rax*8], rcx
mov rcx, [r14+48h]
mov ecx, [rcx+rax*4]
mov [r13+rax*4+0], ecx
inc rax
movsxd rbp, dword ptr [r14+38h]
cmp rax, rbp
jl short loc_128FB
loc_1291F:
mov rdi, [r14+40h]; this
test rdi, rdi
jz short loc_1293A
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rdi, [r14+48h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov ebp, [r14+38h]
loc_1293A:
mov [r14+40h], r12
mov [r14+48h], r13
jmp short loc_12948
loc_12944:
mov r12, [r14+40h]
loc_12948:
mov rdi, r15
call _strdup
movsxd rcx, ebp
mov [r12+rcx*8], rax
mov rax, [r14+48h]
mov [rax+rcx*4], ebx
inc dword ptr [r14+38h]
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long LefDefParser::lefiSite::addRowPattern(LefDefParser::lefiSite *this, char *a2, int a3)
{
long long v5; // rbp
int v6; // ecx
long long v7; // r12
long long v8; // r13
long long v9; // rax
LefDefParser *v10; // rdi
long long result; // rax
LODWORD(v5) = *((_DWORD *)this + 14);
if ( (_DWORD)v5 == *((_DWORD *)this + 15) )
{
v6 = 2;
if ( (_DWORD)v5 )
v6 = 2 * v5;
*((_DWORD *)this + 15) = v6;
v7 = LefDefParser::lefMalloc((LefDefParser *)(8LL * v6), (unsigned long long)a2);
v8 = LefDefParser::lefMalloc((LefDefParser *)(4LL * *((int *)this + 15)), (unsigned long long)a2);
LODWORD(v5) = *((_DWORD *)this + 14);
if ( (int)v5 > 0 )
{
v9 = 0LL;
do
{
*(_QWORD *)(v7 + 8 * v9) = *(_QWORD *)(*((_QWORD *)this + 8) + 8 * v9);
*(_DWORD *)(v8 + 4 * v9) = *(_DWORD *)(*((_QWORD *)this + 9) + 4 * v9);
++v9;
v5 = *((int *)this + 14);
}
while ( v9 < v5 );
}
v10 = (LefDefParser *)*((_QWORD *)this + 8);
if ( v10 )
{
LefDefParser::lefFree(v10, a2);
LefDefParser::lefFree(*((LefDefParser **)this + 9), a2);
LODWORD(v5) = *((_DWORD *)this + 14);
}
*((_QWORD *)this + 8) = v7;
*((_QWORD *)this + 9) = v8;
}
else
{
v7 = *((_QWORD *)this + 8);
}
*(_QWORD *)(v7 + 8LL * (int)v5) = strdup(a2);
result = *((_QWORD *)this + 9);
*(_DWORD *)(result + 4LL * (int)v5) = a3;
++*((_DWORD *)this + 14);
return result;
}
| addRowPattern:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,EDX
MOV R15,RSI
MOV R14,RDI
MOV EBP,dword ptr [RDI + 0x38]
CMP EBP,dword ptr [RDI + 0x3c]
JNZ 0x00112944
LEA EAX,[RBP*0x2]
TEST EBP,EBP
MOV ECX,0x2
CMOVNZ ECX,EAX
MOV dword ptr [R14 + 0x3c],ECX
MOVSXD RDI,ECX
SHL RDI,0x3
CALL 0x00124985
MOV R12,RAX
MOVSXD RDI,dword ptr [R14 + 0x3c]
SHL RDI,0x2
CALL 0x00124985
MOV R13,RAX
MOV EBP,dword ptr [R14 + 0x38]
TEST EBP,EBP
JLE 0x0011291f
XOR EAX,EAX
LAB_001128fb:
MOV RCX,qword ptr [R14 + 0x40]
MOV RCX,qword ptr [RCX + RAX*0x8]
MOV qword ptr [R12 + RAX*0x8],RCX
MOV RCX,qword ptr [R14 + 0x48]
MOV ECX,dword ptr [RCX + RAX*0x4]
MOV dword ptr [R13 + RAX*0x4],ECX
INC RAX
MOVSXD RBP,dword ptr [R14 + 0x38]
CMP RAX,RBP
JL 0x001128fb
LAB_0011291f:
MOV RDI,qword ptr [R14 + 0x40]
TEST RDI,RDI
JZ 0x0011293a
CALL 0x00126040
MOV RDI,qword ptr [R14 + 0x48]
CALL 0x00126040
MOV EBP,dword ptr [R14 + 0x38]
LAB_0011293a:
MOV qword ptr [R14 + 0x40],R12
MOV qword ptr [R14 + 0x48],R13
JMP 0x00112948
LAB_00112944:
MOV R12,qword ptr [R14 + 0x40]
LAB_00112948:
MOV RDI,R15
CALL 0x00102380
MOVSXD RCX,EBP
MOV qword ptr [R12 + RCX*0x8],RAX
MOV RAX,qword ptr [R14 + 0x48]
MOV dword ptr [RAX + RCX*0x4],EBX
INC dword ptr [R14 + 0x38]
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* LefDefParser::lefiSite::addRowPattern(char const*, int) */
void __thiscall LefDefParser::lefiSite::addRowPattern(lefiSite *this,char *param_1,int param_2)
{
long lVar1;
long lVar2;
long lVar3;
char *pcVar4;
int iVar5;
int iVar6;
iVar6 = *(int *)(this + 0x38);
if (iVar6 == *(int *)(this + 0x3c)) {
iVar5 = 2;
if (iVar6 != 0) {
iVar5 = iVar6 * 2;
}
*(int *)(this + 0x3c) = iVar5;
pcVar4 = param_1;
lVar1 = lefMalloc((LefDefParser *)((long)iVar5 << 3),(ulong)param_1);
lVar2 = lefMalloc((LefDefParser *)((long)*(int *)(this + 0x3c) << 2),(ulong)pcVar4);
iVar6 = *(int *)(this + 0x38);
if (0 < iVar6) {
lVar3 = 0;
do {
*(int8 *)(lVar1 + lVar3 * 8) = *(int8 *)(*(long *)(this + 0x40) + lVar3 * 8);
*(int4 *)(lVar2 + lVar3 * 4) = *(int4 *)(*(long *)(this + 0x48) + lVar3 * 4);
lVar3 = lVar3 + 1;
iVar6 = *(int *)(this + 0x38);
} while (lVar3 < iVar6);
}
if (*(void **)(this + 0x40) != (void *)0x0) {
lefFree(*(void **)(this + 0x40));
lefFree(*(void **)(this + 0x48));
iVar6 = *(int *)(this + 0x38);
}
*(long *)(this + 0x40) = lVar1;
*(long *)(this + 0x48) = lVar2;
}
else {
lVar1 = *(long *)(this + 0x40);
}
pcVar4 = strdup(param_1);
*(char **)(lVar1 + (long)iVar6 * 8) = pcVar4;
*(int *)(*(long *)(this + 0x48) + (long)iVar6 * 4) = param_2;
*(int *)(this + 0x38) = *(int *)(this + 0x38) + 1;
return;
}
| |
51,204 | maria_rtree_rect_volume | eloqsql/storage/maria/ma_rt_mbr.c | double maria_rtree_rect_volume(HA_KEYSEG *keyseg, uchar *a, uint key_length)
{
double res= 1;
for (; (int)key_length > 0; keyseg += 2)
{
uint32 keyseg_length;
switch ((enum ha_base_keytype) keyseg->type) {
case HA_KEYTYPE_INT8:
RT_VOL_KORR(int8, mi_sint1korr, 1, (double));
break;
case HA_KEYTYPE_BINARY:
RT_VOL_KORR(uint8, mi_uint1korr, 1, (double));
break;
case HA_KEYTYPE_SHORT_INT:
RT_VOL_KORR(int16, mi_sint2korr, 2, (double));
break;
case HA_KEYTYPE_USHORT_INT:
RT_VOL_KORR(uint16, mi_uint2korr, 2, (double));
break;
case HA_KEYTYPE_INT24:
RT_VOL_KORR(int32, mi_sint3korr, 3, (double));
break;
case HA_KEYTYPE_UINT24:
RT_VOL_KORR(uint32, mi_uint3korr, 3, (double));
break;
case HA_KEYTYPE_LONG_INT:
RT_VOL_KORR(int32, mi_sint4korr, 4, (double));
break;
case HA_KEYTYPE_ULONG_INT:
RT_VOL_KORR(uint32, mi_uint4korr, 4, (double));
break;
#ifdef HAVE_LONG_LONG
case HA_KEYTYPE_LONGLONG:
RT_VOL_KORR(longlong, mi_sint8korr, 8, (double));
break;
case HA_KEYTYPE_ULONGLONG:
RT_VOL_KORR(longlong, mi_sint8korr, 8, ulonglong2double);
break;
#endif
case HA_KEYTYPE_FLOAT:
RT_VOL_GET(float, mi_float4get, 4, (double));
break;
case HA_KEYTYPE_DOUBLE:
RT_VOL_GET(double, mi_float8get, 8, (double));
break;
case HA_KEYTYPE_END:
key_length= 0;
break;
default:
return -1;
}
keyseg_length= keyseg->length * 2;
key_length-= keyseg_length;
a+= keyseg_length;
}
return res;
} | O3 | c | maria_rtree_rect_volume:
pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
jle 0x768f7
addq $0x18, %rdi
movsd 0x97368(%rip), %xmm0 # 0x10da08
movsd 0x97380(%rip), %xmm1 # 0x10da28
leaq 0x97755(%rip), %rax # 0x10de04
movq 0x97029(%rip), %xmm2 # 0x10d6e0
movapd 0x97031(%rip), %xmm3 # 0x10d6f0
movzbl (%rdi), %ecx
cmpq $0xe, %rcx
ja 0x76901
movslq (%rax,%rcx,4), %r8
addq %rax, %r8
jmpq *%r8
movl %ecx, %edx
jmp 0x7686b
movq (%rsi), %rcx
movq 0x8(%rsi), %r8
bswapq %rcx
bswapq %r8
movq %rcx, %xmm4
movq %r8, %xmm5
jmp 0x767dd
movzbl (%rsi), %ecx
leal 0x1(%rcx), %r8d
movzbl %r8b, %r8d
jmp 0x76837
movl (%rsi), %ecx
movl 0x4(%rsi), %r8d
bswapl %ecx
bswapl %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
jmp 0x767b5
movq (%rsi), %rcx
movq 0x8(%rsi), %r8
bswapq %rcx
bswapq %r8
jmp 0x76853
movzwl (%rsi), %ecx
movzwl 0x2(%rsi), %r8d
rolw $0x8, %cx
rolw $0x8, %r8w
movswl %r8w, %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
movswl %cx, %ecx
jmp 0x767b5
movzwl 0x1(%rsi), %ecx
movzwl 0x4(%rsi), %r8d
rolw $0x8, %cx
movzwl %cx, %ecx
movzbl (%rsi), %r9d
shll $0x10, %r9d
orl %ecx, %r9d
rolw $0x8, %r8w
movzwl %r8w, %ecx
movzbl 0x3(%rsi), %r8d
shll $0x10, %r8d
orl %ecx, %r8d
subl %r9d, %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
jmp 0x76867
movzwl (%rsi), %ecx
movzwl 0x2(%rsi), %r8d
rolw $0x8, %cx
rolw $0x8, %r8w
movzwl %r8w, %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
movzwl %cx, %ecx
xorps %xmm5, %xmm5
cvtsi2sd %ecx, %xmm5
jmp 0x76863
movl (%rsi), %ecx
movl 0x4(%rsi), %r8d
bswapl %ecx
movd %ecx, %xmm4
bswapl %r8d
movd %r8d, %xmm5
cvtss2sd %xmm5, %xmm5
cvtss2sd %xmm4, %xmm4
subsd %xmm4, %xmm5
jmp 0x76826
movq (%rsi), %rcx
movq 0x8(%rsi), %r8
bswapq %rcx
bswapq %r8
movq %r8, %xmm4
punpckldq %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
subpd %xmm3, %xmm4
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5 # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
movq %rcx, %xmm4
punpckldq %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
subpd %xmm3, %xmm4
movapd %xmm4, %xmm6
unpckhpd %xmm4, %xmm6 # xmm6 = xmm6[1],xmm4[1]
addsd %xmm4, %xmm6
subsd %xmm6, %xmm5
mulsd %xmm5, %xmm0
jmp 0x7686b
movsbl (%rsi), %ecx
leal 0x1(%rcx), %r8d
movsbl %r8b, %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
xorps %xmm5, %xmm5
cvtsi2sd %ecx, %xmm5
jmp 0x76863
movl (%rsi), %ecx
movl 0x4(%rsi), %r8d
bswapl %ecx
bswapl %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8, %xmm4
xorps %xmm5, %xmm5
cvtsi2sd %rcx, %xmm5
subsd %xmm5, %xmm4
mulsd %xmm4, %xmm0
movzwl -0x4(%rdi), %ecx
addl %ecx, %ecx
addq %rcx, %rsi
addq $0x40, %rdi
subl %ecx, %edx
jg 0x766bf
jmp 0x768ff
movzbl (%rsi), %r10d
movl %r10d, %ecx
shll $0x10, %ecx
movzbl 0x1(%rsi), %r8d
shll $0x8, %r8d
movzbl 0x2(%rsi), %r9d
testb %r10b, %r10b
js 0x768a7
orl %r9d, %ecx
orl %r8d, %ecx
jmp 0x768b3
orl %r9d, %r8d
addl %r8d, %ecx
addl $0xff000000, %ecx # imm = 0xFF000000
movzbl 0x3(%rsi), %r11d
movl %r11d, %r8d
shll $0x10, %r8d
movzbl 0x4(%rsi), %r9d
shll $0x8, %r9d
movzbl 0x5(%rsi), %r10d
testb %r11b, %r11b
js 0x768da
orl %r10d, %r8d
orl %r9d, %r8d
jmp 0x768e7
orl %r10d, %r9d
addl %r9d, %r8d
addl $0xff000000, %r8d # imm = 0xFF000000
subl %ecx, %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
jmp 0x76867
movsd 0x97109(%rip), %xmm0 # 0x10da08
popq %rbp
retq
movapd %xmm1, %xmm0
jmp 0x768ff
| maria_rtree_rect_volume:
push rbp
mov rbp, rsp
test edx, edx
jle loc_768F7
add rdi, 18h
movsd xmm0, cs:qword_10DA08
movsd xmm1, cs:qword_10DA28
lea rax, jpt_766D3
movq xmm2, qword ptr cs:xmmword_10D6E0
movapd xmm3, cs:xmmword_10D6F0
loc_766BF:
movzx ecx, byte ptr [rdi]
cmp rcx, 0Eh; switch 15 cases
ja def_766D3; jumptable 00000000000766D3 default case, cases 1,7
movsxd r8, ds:(jpt_766D3 - 10DE04h)[rax+rcx*4]
add r8, rax
jmp r8; switch jump
loc_766D6:
mov edx, ecx; jumptable 00000000000766D3 case 0
jmp loc_7686B
loc_766DD:
mov rcx, [rsi]; jumptable 00000000000766D3 case 6
mov r8, [rsi+8]
bswap rcx
bswap r8
movq xmm4, rcx
movq xmm5, r8
jmp loc_767DD
loc_766F9:
movzx ecx, byte ptr [rsi]; jumptable 00000000000766D3 case 2
lea r8d, [rcx+1]
movzx r8d, r8b
jmp loc_76837
loc_76709:
mov ecx, [rsi]; jumptable 00000000000766D3 case 4
mov r8d, [rsi+4]
bswap ecx
bswap r8d
xorps xmm4, xmm4
cvtsi2sd xmm4, r8d
jmp loc_767B5
loc_76721:
mov rcx, [rsi]; jumptable 00000000000766D3 case 10
mov r8, [rsi+8]
bswap rcx
bswap r8
jmp loc_76853
loc_76733:
movzx ecx, word ptr [rsi]; jumptable 00000000000766D3 case 3
movzx r8d, word ptr [rsi+2]
rol cx, 8
rol r8w, 8
movsx r8d, r8w
xorps xmm4, xmm4
cvtsi2sd xmm4, r8d
movsx ecx, cx
jmp short loc_767B5
loc_76755:
movzx ecx, word ptr [rsi+1]; jumptable 00000000000766D3 case 13
movzx r8d, word ptr [rsi+4]
rol cx, 8
movzx ecx, cx
movzx r9d, byte ptr [rsi]
shl r9d, 10h
or r9d, ecx
rol r8w, 8
movzx ecx, r8w
movzx r8d, byte ptr [rsi+3]
shl r8d, 10h
or r8d, ecx
sub r8d, r9d
xorps xmm4, xmm4
cvtsi2sd xmm4, r8d
jmp loc_76867
loc_76795:
movzx ecx, word ptr [rsi]; jumptable 00000000000766D3 case 8
movzx r8d, word ptr [rsi+2]
rol cx, 8
rol r8w, 8
movzx r8d, r8w
xorps xmm4, xmm4
cvtsi2sd xmm4, r8d
movzx ecx, cx
loc_767B5:
xorps xmm5, xmm5
cvtsi2sd xmm5, ecx
jmp loc_76863
loc_767C1:
mov ecx, [rsi]; jumptable 00000000000766D3 case 5
mov r8d, [rsi+4]
bswap ecx
movd xmm4, ecx
bswap r8d
movd xmm5, r8d
cvtss2sd xmm5, xmm5
cvtss2sd xmm4, xmm4
loc_767DD:
subsd xmm5, xmm4
jmp short loc_76826
loc_767E3:
mov rcx, [rsi]; jumptable 00000000000766D3 case 11
mov r8, [rsi+8]
bswap rcx
bswap r8
movq xmm4, r8
punpckldq xmm4, xmm2
subpd xmm4, xmm3
movapd xmm5, xmm4
unpckhpd xmm5, xmm4
addsd xmm5, xmm4
movq xmm4, rcx
punpckldq xmm4, xmm2
subpd xmm4, xmm3
movapd xmm6, xmm4
unpckhpd xmm6, xmm4
addsd xmm6, xmm4
subsd xmm5, xmm6
loc_76826:
mulsd xmm0, xmm5
jmp short loc_7686B
loc_7682C:
movsx ecx, byte ptr [rsi]; jumptable 00000000000766D3 case 14
lea r8d, [rcx+1]
movsx r8d, r8b
loc_76837:
xorps xmm4, xmm4
cvtsi2sd xmm4, r8d
xorps xmm5, xmm5
cvtsi2sd xmm5, ecx
jmp short loc_76863
loc_76848:
mov ecx, [rsi]; jumptable 00000000000766D3 case 9
mov r8d, [rsi+4]
bswap ecx
bswap r8d
loc_76853:
xorps xmm4, xmm4
cvtsi2sd xmm4, r8
xorps xmm5, xmm5
cvtsi2sd xmm5, rcx
loc_76863:
subsd xmm4, xmm5
loc_76867:
mulsd xmm0, xmm4
loc_7686B:
movzx ecx, word ptr [rdi-4]
add ecx, ecx
add rsi, rcx
add rdi, 40h ; '@'
sub edx, ecx
jg loc_766BF
jmp short loc_768FF
loc_76882:
movzx r10d, byte ptr [rsi]; jumptable 00000000000766D3 case 12
mov ecx, r10d
shl ecx, 10h
movzx r8d, byte ptr [rsi+1]
shl r8d, 8
movzx r9d, byte ptr [rsi+2]
test r10b, r10b
js short loc_768A7
or ecx, r9d
or ecx, r8d
jmp short loc_768B3
loc_768A7:
or r8d, r9d
add ecx, r8d
add ecx, 0FF000000h
loc_768B3:
movzx r11d, byte ptr [rsi+3]
mov r8d, r11d
shl r8d, 10h
movzx r9d, byte ptr [rsi+4]
shl r9d, 8
movzx r10d, byte ptr [rsi+5]
test r11b, r11b
js short loc_768DA
or r8d, r10d
or r8d, r9d
jmp short loc_768E7
loc_768DA:
or r9d, r10d
add r8d, r9d
add r8d, 0FF000000h
loc_768E7:
sub r8d, ecx
xorps xmm4, xmm4
cvtsi2sd xmm4, r8d
jmp loc_76867
loc_768F7:
movsd xmm0, cs:qword_10DA08
loc_768FF:
pop rbp
retn
def_766D3:
movapd xmm0, xmm1; jumptable 00000000000766D3 default case, cases 1,7
jmp short loc_768FF
| double maria_rtree_rect_volume(long long a1, _WORD *a2, int a3)
{
_BYTE *v3; // rdi
double result; // xmm0_8
__m128i v5; // xmm2
double v6; // xmm4_8
double v7; // xmm5_8
int v8; // ecx
int v9; // r8d
int v10; // ecx
double v11; // xmm4_8
int v12; // ecx
int v13; // r8d
double v14; // xmm4_8
double v15; // xmm5_8
double v16; // xmm5_8
__m128d v17; // xmm4
double v18; // xmm5_8
__m128d v19; // xmm4
long long v20; // rcx
bool v21; // cc
int v22; // ecx
int v23; // r8d
int v24; // r9d
int v25; // ecx
int v26; // r8d
int v27; // r9d
int v28; // r10d
int v29; // r8d
if ( a3 > 0 )
{
v3 = (_BYTE *)(a1 + 24);
result = 1.0;
v5 = _mm_loadl_epi64((const __m128i *)&xmmword_10D6E0);
while ( 2 )
{
switch ( *v3 )
{
case 0:
a3 = (unsigned __int8)*v3;
goto LABEL_23;
case 2:
v8 = *(unsigned __int8 *)a2;
v9 = (unsigned __int8)(v8 + 1);
goto LABEL_18;
case 3:
v11 = (double)(__int16)__ROL2__(a2[1], 8);
v10 = (__int16)__ROL2__(*a2, 8);
goto LABEL_12;
case 4:
v10 = _byteswap_ulong(*(_DWORD *)a2);
v11 = (double)(int)_byteswap_ulong(*((_DWORD *)a2 + 1));
goto LABEL_12;
case 5:
v7 = COERCE_FLOAT(_byteswap_ulong(*((_DWORD *)a2 + 1)));
v6 = COERCE_FLOAT(_byteswap_ulong(*(_DWORD *)a2));
goto LABEL_14;
case 6:
v6 = COERCE_DOUBLE(_byteswap_uint64(*(_QWORD *)a2));
v7 = COERCE_DOUBLE(_byteswap_uint64(*((_QWORD *)a2 + 1)));
LABEL_14:
v16 = v7 - v6;
goto LABEL_16;
case 8:
v11 = (double)(unsigned __int16)__ROL2__(a2[1], 8);
v10 = (unsigned __int16)__ROL2__(*a2, 8);
LABEL_12:
v15 = (double)v10;
goto LABEL_21;
case 9:
v12 = _byteswap_ulong(*(_DWORD *)a2);
v13 = _byteswap_ulong(*((_DWORD *)a2 + 1));
goto LABEL_20;
case 0xA:
v12 = _byteswap_uint64(*(_QWORD *)a2);
v13 = _byteswap_uint64(*((_QWORD *)a2 + 1));
LABEL_20:
v11 = (double)v13;
v15 = (double)v12;
goto LABEL_21;
case 0xB:
v17 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32((__m128i)_byteswap_uint64(*((_QWORD *)a2 + 1)), v5),
(__m128d)xmmword_10D6F0);
v18 = _mm_unpackhi_pd(v17, v17).m128d_f64[0] + v17.m128d_f64[0];
v19 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32((__m128i)_byteswap_uint64(*(_QWORD *)a2), v5),
(__m128d)xmmword_10D6F0);
v16 = v18 - (_mm_unpackhi_pd(v19, v19).m128d_f64[0] + v19.m128d_f64[0]);
LABEL_16:
result = result * v16;
goto LABEL_23;
case 0xC:
v22 = *(unsigned __int8 *)a2 << 16;
v23 = *((unsigned __int8 *)a2 + 1) << 8;
v24 = *((unsigned __int8 *)a2 + 2);
if ( *(char *)a2 < 0 )
v25 = (v24 | v23) + v22 - 0x1000000;
else
v25 = v23 | v24 | v22;
v26 = *((unsigned __int8 *)a2 + 3) << 16;
v27 = *((unsigned __int8 *)a2 + 4) << 8;
v28 = *((unsigned __int8 *)a2 + 5);
if ( *((char *)a2 + 3) < 0 )
v29 = (v28 | v27) + v26 - 0x1000000;
else
v29 = v27 | v28 | v26;
v14 = (double)(v29 - v25);
goto LABEL_22;
case 0xD:
v14 = (double)(((unsigned __int16)__ROL2__(a2[2], 8) | (*((unsigned __int8 *)a2 + 3) << 16))
- ((unsigned __int16)__ROL2__(*(_WORD *)((char *)a2 + 1), 8) | (*(unsigned __int8 *)a2 << 16)));
goto LABEL_22;
case 0xE:
v8 = *(char *)a2;
v9 = (char)(*(_BYTE *)a2 + 1);
LABEL_18:
v11 = (double)v9;
v15 = (double)v8;
LABEL_21:
v14 = v11 - v15;
LABEL_22:
result = result * v14;
LABEL_23:
v20 = 2 * (unsigned int)*((unsigned __int16 *)v3 - 2);
a2 = (_WORD *)((char *)a2 + v20);
v3 += 64;
v21 = a3 <= (int)v20;
a3 -= v20;
if ( v21 )
return result;
continue;
default:
return -1.0;
}
}
}
return 1.0;
}
| maria_rtree_rect_volume:
PUSH RBP
MOV RBP,RSP
TEST EDX,EDX
JLE 0x001768f7
ADD RDI,0x18
MOVSD XMM0,qword ptr [0x0020da08]
MOVSD XMM1,qword ptr [0x0020da28]
LEA RAX,[0x20de04]
MOVQ XMM2,qword ptr [0x0020d6e0]
MOVAPD XMM3,xmmword ptr [0x0020d6f0]
LAB_001766bf:
MOVZX ECX,byte ptr [RDI]
CMP RCX,0xe
JA 0x00176901
MOVSXD R8,dword ptr [RAX + RCX*0x4]
ADD R8,RAX
switchD:
JMP R8
caseD_0:
MOV EDX,ECX
JMP 0x0017686b
caseD_6:
MOV RCX,qword ptr [RSI]
MOV R8,qword ptr [RSI + 0x8]
BSWAP RCX
BSWAP R8
MOVQ XMM4,RCX
MOVQ XMM5,R8
JMP 0x001767dd
caseD_2:
MOVZX ECX,byte ptr [RSI]
LEA R8D,[RCX + 0x1]
MOVZX R8D,R8B
JMP 0x00176837
caseD_4:
MOV ECX,dword ptr [RSI]
MOV R8D,dword ptr [RSI + 0x4]
BSWAP ECX
BSWAP R8D
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8D
JMP 0x001767b5
caseD_a:
MOV RCX,qword ptr [RSI]
MOV R8,qword ptr [RSI + 0x8]
BSWAP RCX
BSWAP R8
JMP 0x00176853
caseD_3:
MOVZX ECX,word ptr [RSI]
MOVZX R8D,word ptr [RSI + 0x2]
ROL CX,0x8
ROL R8W,0x8
MOVSX R8D,R8W
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8D
MOVSX ECX,CX
JMP 0x001767b5
caseD_d:
MOVZX ECX,word ptr [RSI + 0x1]
MOVZX R8D,word ptr [RSI + 0x4]
ROL CX,0x8
MOVZX ECX,CX
MOVZX R9D,byte ptr [RSI]
SHL R9D,0x10
OR R9D,ECX
ROL R8W,0x8
MOVZX ECX,R8W
MOVZX R8D,byte ptr [RSI + 0x3]
SHL R8D,0x10
OR R8D,ECX
SUB R8D,R9D
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8D
JMP 0x00176867
caseD_8:
MOVZX ECX,word ptr [RSI]
MOVZX R8D,word ptr [RSI + 0x2]
ROL CX,0x8
ROL R8W,0x8
MOVZX R8D,R8W
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8D
MOVZX ECX,CX
LAB_001767b5:
XORPS XMM5,XMM5
CVTSI2SD XMM5,ECX
JMP 0x00176863
caseD_5:
MOV ECX,dword ptr [RSI]
MOV R8D,dword ptr [RSI + 0x4]
BSWAP ECX
MOVD XMM4,ECX
BSWAP R8D
MOVD XMM5,R8D
CVTSS2SD XMM5,XMM5
CVTSS2SD XMM4,XMM4
LAB_001767dd:
SUBSD XMM5,XMM4
JMP 0x00176826
caseD_b:
MOV RCX,qword ptr [RSI]
MOV R8,qword ptr [RSI + 0x8]
BSWAP RCX
BSWAP R8
MOVQ XMM4,R8
PUNPCKLDQ XMM4,XMM2
SUBPD XMM4,XMM3
MOVAPD XMM5,XMM4
UNPCKHPD XMM5,XMM4
ADDSD XMM5,XMM4
MOVQ XMM4,RCX
PUNPCKLDQ XMM4,XMM2
SUBPD XMM4,XMM3
MOVAPD XMM6,XMM4
UNPCKHPD XMM6,XMM4
ADDSD XMM6,XMM4
SUBSD XMM5,XMM6
LAB_00176826:
MULSD XMM0,XMM5
JMP 0x0017686b
caseD_e:
MOVSX ECX,byte ptr [RSI]
LEA R8D,[RCX + 0x1]
MOVSX R8D,R8B
LAB_00176837:
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8D
XORPS XMM5,XMM5
CVTSI2SD XMM5,ECX
JMP 0x00176863
caseD_9:
MOV ECX,dword ptr [RSI]
MOV R8D,dword ptr [RSI + 0x4]
BSWAP ECX
BSWAP R8D
LAB_00176853:
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8
XORPS XMM5,XMM5
CVTSI2SD XMM5,RCX
LAB_00176863:
SUBSD XMM4,XMM5
LAB_00176867:
MULSD XMM0,XMM4
LAB_0017686b:
MOVZX ECX,word ptr [RDI + -0x4]
ADD ECX,ECX
ADD RSI,RCX
ADD RDI,0x40
SUB EDX,ECX
JG 0x001766bf
JMP 0x001768ff
caseD_c:
MOVZX R10D,byte ptr [RSI]
MOV ECX,R10D
SHL ECX,0x10
MOVZX R8D,byte ptr [RSI + 0x1]
SHL R8D,0x8
MOVZX R9D,byte ptr [RSI + 0x2]
TEST R10B,R10B
JS 0x001768a7
OR ECX,R9D
OR ECX,R8D
JMP 0x001768b3
LAB_001768a7:
OR R8D,R9D
ADD ECX,R8D
ADD ECX,0xff000000
LAB_001768b3:
MOVZX R11D,byte ptr [RSI + 0x3]
MOV R8D,R11D
SHL R8D,0x10
MOVZX R9D,byte ptr [RSI + 0x4]
SHL R9D,0x8
MOVZX R10D,byte ptr [RSI + 0x5]
TEST R11B,R11B
JS 0x001768da
OR R8D,R10D
OR R8D,R9D
JMP 0x001768e7
LAB_001768da:
OR R9D,R10D
ADD R8D,R9D
ADD R8D,0xff000000
LAB_001768e7:
SUB R8D,ECX
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8D
JMP 0x00176867
LAB_001768f7:
MOVSD XMM0,qword ptr [0x0020da08]
LAB_001768ff:
POP RBP
RET
caseD_1:
MOVAPD XMM0,XMM1
JMP 0x001768ff
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double maria_rtree_rect_volume(long param_1,ulong *param_2,uint param_3)
{
ushort *puVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
byte *pbVar5;
uint uVar6;
ulong uVar7;
ulong uVar8;
bool bVar9;
double dVar10;
double dVar11;
int1 auVar12 [16];
int1 auVar13 [16];
double dVar14;
dVar10 = DAT_0020da08;
if (0 < (int)param_3) {
pbVar5 = (byte *)(param_1 + 0x18);
do {
switch(*pbVar5) {
case 0:
param_3 = (uint)*pbVar5;
goto LAB_0017686b;
default:
return DAT_0020da28;
case 2:
uVar2 = (uint)(byte)*param_2;
uVar6 = (byte)*param_2 + 1 & 0xff;
goto LAB_00176837;
case 3:
dVar11 = (double)(int)(short)(*(ushort *)((long)param_2 + 2) << 8 |
*(ushort *)((long)param_2 + 2) >> 8);
uVar2 = (uint)(short)((ushort)*param_2 << 8 | (ushort)*param_2 >> 8);
break;
case 4:
uVar2 = (uint)*param_2;
uVar6 = *(uint *)((long)param_2 + 4);
uVar2 = uVar2 >> 0x18 | (uVar2 & 0xff0000) >> 8 | (uVar2 & 0xff00) << 8 | uVar2 << 0x18;
dVar11 = (double)(int)(uVar6 >> 0x18 | (uVar6 & 0xff0000) >> 8 | (uVar6 & 0xff00) << 8 |
uVar6 << 0x18);
break;
case 5:
uVar2 = (uint)*param_2;
uVar6 = *(uint *)((long)param_2 + 4);
dVar11 = (double)(float)(uVar6 >> 0x18 | (uVar6 & 0xff0000) >> 8 | (uVar6 & 0xff00) << 8 |
uVar6 << 0x18);
dVar14 = (double)(float)(uVar2 >> 0x18 | (uVar2 & 0xff0000) >> 8 | (uVar2 & 0xff00) << 8 |
uVar2 << 0x18);
goto LAB_001767dd;
case 6:
uVar3 = *param_2;
uVar7 = param_2[1];
dVar14 = (double)(uVar3 >> 0x38 | (uVar3 & 0xff000000000000) >> 0x28 |
(uVar3 & 0xff0000000000) >> 0x18 | (uVar3 & 0xff00000000) >> 8 |
(uVar3 & 0xff000000) << 8 | (uVar3 & 0xff0000) << 0x18 |
(uVar3 & 0xff00) << 0x28 | uVar3 << 0x38);
dVar11 = (double)(uVar7 >> 0x38 | (uVar7 & 0xff000000000000) >> 0x28 |
(uVar7 & 0xff0000000000) >> 0x18 | (uVar7 & 0xff00000000) >> 8 |
(uVar7 & 0xff000000) << 8 | (uVar7 & 0xff0000) << 0x18 |
(uVar7 & 0xff00) << 0x28 | uVar7 << 0x38);
LAB_001767dd:
dVar11 = dVar11 - dVar14;
LAB_00176826:
dVar10 = dVar10 * dVar11;
goto LAB_0017686b;
case 8:
dVar11 = (double)(ushort)(*(ushort *)((long)param_2 + 2) << 8 |
*(ushort *)((long)param_2 + 2) >> 8);
uVar2 = (uint)(ushort)((ushort)*param_2 << 8 | (ushort)*param_2 >> 8);
break;
case 9:
uVar2 = (uint)*param_2;
uVar6 = *(uint *)((long)param_2 + 4);
uVar3 = (ulong)(uVar2 >> 0x18 | (uVar2 & 0xff0000) >> 8 | (uVar2 & 0xff00) << 8 |
uVar2 << 0x18);
uVar7 = (ulong)(uVar6 >> 0x18 | (uVar6 & 0xff0000) >> 8 | (uVar6 & 0xff00) << 8 |
uVar6 << 0x18);
goto LAB_00176853;
case 10:
uVar3 = *param_2;
uVar7 = param_2[1];
uVar3 = uVar3 >> 0x38 | (uVar3 & 0xff000000000000) >> 0x28 |
(uVar3 & 0xff0000000000) >> 0x18 | (uVar3 & 0xff00000000) >> 8 |
(uVar3 & 0xff000000) << 8 | (uVar3 & 0xff0000) << 0x18 | (uVar3 & 0xff00) << 0x28 |
uVar3 << 0x38;
uVar7 = uVar7 >> 0x38 | (uVar7 & 0xff000000000000) >> 0x28 |
(uVar7 & 0xff0000000000) >> 0x18 | (uVar7 & 0xff00000000) >> 8 |
(uVar7 & 0xff000000) << 8 | (uVar7 & 0xff0000) << 0x18 | (uVar7 & 0xff00) << 0x28 |
uVar7 << 0x38;
LAB_00176853:
dVar11 = (double)(long)uVar7;
dVar14 = (double)(long)uVar3;
goto LAB_00176863;
case 0xb:
uVar3 = *param_2;
uVar7 = param_2[1];
uVar4 = (uVar3 & 0xff000000) << 8 | (uVar3 & 0xff0000) << 0x18 | (uVar3 & 0xff00) << 0x28 |
uVar3 << 0x38;
uVar8 = (uVar7 & 0xff000000) << 8 | (uVar7 & 0xff0000) << 0x18 | (uVar7 & 0xff00) << 0x28 |
uVar7 << 0x38;
auVar12._8_4_ = (int)(uVar8 >> 0x20);
auVar12._0_8_ = uVar8;
auVar12._12_4_ = DAT_0020d6e0._4_4_;
auVar13._8_4_ = (int)(uVar4 >> 0x20);
auVar13._0_8_ = uVar4;
auVar13._12_4_ = DAT_0020d6e0._4_4_;
dVar11 = ((auVar12._8_8_ - _UNK_0020d6f8) +
((double)CONCAT44((int4)DAT_0020d6e0,
(uint)(byte)(uVar7 >> 0x38) |
((uint)(uVar7 >> 0x20) & 0xff0000) >> 8 |
(uint)(uVar7 >> 0x18) & 0xff0000 |
(uint)(uVar7 >> 8) & 0xff000000) - _DAT_0020d6f0)) -
((auVar13._8_8_ - _UNK_0020d6f8) +
((double)CONCAT44((int4)DAT_0020d6e0,
(uint)(byte)(uVar3 >> 0x38) |
((uint)(uVar3 >> 0x20) & 0xff0000) >> 8 |
(uint)(uVar3 >> 0x18) & 0xff0000 |
(uint)(uVar3 >> 8) & 0xff000000) - _DAT_0020d6f0));
goto LAB_00176826;
case 0xc:
uVar2 = (uint)(byte)*param_2 * 0x10000;
if ((char)(byte)*param_2 < '\0') {
uVar2 = (uVar2 + CONCAT11(*(byte *)((long)param_2 + 1),*(byte *)((long)param_2 + 2))) -
0x1000000;
}
else {
uVar2 = uVar2 | *(byte *)((long)param_2 + 2) | (uint)*(byte *)((long)param_2 + 1) << 8;
}
uVar6 = (uint)*(byte *)((long)param_2 + 3) * 0x10000;
if ((char)*(byte *)((long)param_2 + 3) < '\0') {
uVar6 = (uVar6 + CONCAT11(*(byte *)((long)param_2 + 4),*(byte *)((long)param_2 + 5))) -
0x1000000;
}
else {
uVar6 = uVar6 | *(byte *)((long)param_2 + 5) | (uint)*(byte *)((long)param_2 + 4) << 8;
}
dVar11 = (double)(int)(uVar6 - uVar2);
goto LAB_00176867;
case 0xd:
dVar11 = (double)(int)((uint)CONCAT12(*(byte *)((long)param_2 + 3),
*(ushort *)((long)param_2 + 4) << 8 |
*(ushort *)((long)param_2 + 4) >> 8) -
(uint)CONCAT12((byte)*param_2,
*(ushort *)((long)param_2 + 1) << 8 |
*(ushort *)((long)param_2 + 1) >> 8));
goto LAB_00176867;
case 0xe:
uVar2 = (uint)(char)(byte)*param_2;
uVar6 = (uint)(char)((byte)*param_2 + 1);
LAB_00176837:
dVar11 = (double)(int)uVar6;
dVar14 = (double)(int)uVar2;
goto LAB_00176863;
}
dVar14 = (double)(int)uVar2;
LAB_00176863:
dVar11 = dVar11 - dVar14;
LAB_00176867:
dVar10 = dVar10 * dVar11;
LAB_0017686b:
puVar1 = (ushort *)(pbVar5 + -4);
uVar2 = (uint)*puVar1 * 2;
param_2 = (ulong *)((long)param_2 + (ulong)uVar2);
pbVar5 = pbVar5 + 0x40;
bVar9 = SBORROW4(param_3,uVar2);
param_3 = param_3 + (uint)*puVar1 * -2;
} while (param_3 != 0 && bVar9 == (int)param_3 < 0);
}
return dVar10;
}
| |
51,205 | hi0bits | eloqsql/strings/dtoa.c | static int hi0bits(register ULong x)
{
register int k= 0;
if (!(x & 0xffff0000))
{
k= 16;
x<<= 16;
}
if (!(x & 0xff000000))
{
k+= 8;
x<<= 8;
}
if (!(x & 0xf0000000))
{
k+= 4;
x<<= 4;
}
if (!(x & 0xc0000000))
{
k+= 2;
x<<= 2;
}
if (!(x & 0x80000000))
{
k++;
if (!(x & 0x40000000))
return 32;
}
return k;
} | O0 | c | hi0bits:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff0000, %eax # imm = 0xFFFF0000
cmpl $0x0, %eax
jne 0x7940b
movl $0x10, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x10, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xff000000, %eax # imm = 0xFF000000
cmpl $0x0, %eax
jne 0x7942a
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xf0000000, %eax # imm = 0xF0000000
cmpl $0x0, %eax
jne 0x79449
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xc0000000, %eax # imm = 0xC0000000
cmpl $0x0, %eax
jne 0x79468
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
jne 0x79496
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0x40000000, %eax # imm = 0x40000000
cmpl $0x0, %eax
jne 0x79494
movl $0x20, -0x4(%rbp)
jmp 0x7949c
jmp 0x79496
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| hi0bits:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
mov [rbp+var_C], 0
mov eax, [rbp+var_8]
and eax, 0FFFF0000h
cmp eax, 0
jnz short loc_7940B
mov [rbp+var_C], 10h
mov eax, [rbp+var_8]
shl eax, 10h
mov [rbp+var_8], eax
loc_7940B:
mov eax, [rbp+var_8]
and eax, 0FF000000h
cmp eax, 0
jnz short loc_7942A
mov eax, [rbp+var_C]
add eax, 8
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shl eax, 8
mov [rbp+var_8], eax
loc_7942A:
mov eax, [rbp+var_8]
and eax, 0F0000000h
cmp eax, 0
jnz short loc_79449
mov eax, [rbp+var_C]
add eax, 4
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shl eax, 4
mov [rbp+var_8], eax
loc_79449:
mov eax, [rbp+var_8]
and eax, 0C0000000h
cmp eax, 0
jnz short loc_79468
mov eax, [rbp+var_C]
add eax, 2
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shl eax, 2
mov [rbp+var_8], eax
loc_79468:
mov eax, [rbp+var_8]
and eax, 80000000h
cmp eax, 0
jnz short loc_79496
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
and eax, 40000000h
cmp eax, 0
jnz short loc_79494
mov [rbp+var_4], 20h ; ' '
jmp short loc_7949C
loc_79494:
jmp short $+2
loc_79496:
mov eax, [rbp+var_C]
mov [rbp+var_4], eax
loc_7949C:
mov eax, [rbp+var_4]
pop rbp
retn
| long long hi0bits(int a1)
{
unsigned int v2; // [rsp+0h] [rbp-Ch]
int v3; // [rsp+4h] [rbp-8h]
v3 = a1;
v2 = 0;
if ( (a1 & 0xFFFF0000) == 0 )
{
v2 = 16;
v3 = a1 << 16;
}
if ( (v3 & 0xFF000000) == 0 )
{
v2 += 8;
v3 <<= 8;
}
if ( (v3 & 0xF0000000) == 0 )
{
v2 += 4;
v3 *= 16;
}
if ( (v3 & 0xC0000000) == 0 )
{
v2 += 2;
v3 *= 4;
}
if ( v3 < 0 )
return v2;
++v2;
if ( (v3 & 0x40000000) != 0 )
return v2;
else
return 32;
}
| hi0bits:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0xffff0000
CMP EAX,0x0
JNZ 0x0017940b
MOV dword ptr [RBP + -0xc],0x10
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x10
MOV dword ptr [RBP + -0x8],EAX
LAB_0017940b:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0xff000000
CMP EAX,0x0
JNZ 0x0017942a
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x8
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x8
MOV dword ptr [RBP + -0x8],EAX
LAB_0017942a:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0xf0000000
CMP EAX,0x0
JNZ 0x00179449
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x4
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x4
MOV dword ptr [RBP + -0x8],EAX
LAB_00179449:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0xc0000000
CMP EAX,0x0
JNZ 0x00179468
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x2
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x2
MOV dword ptr [RBP + -0x8],EAX
LAB_00179468:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0x80000000
CMP EAX,0x0
JNZ 0x00179496
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0x40000000
CMP EAX,0x0
JNZ 0x00179494
MOV dword ptr [RBP + -0x4],0x20
JMP 0x0017949c
LAB_00179494:
JMP 0x00179496
LAB_00179496:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x4],EAX
LAB_0017949c:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int hi0bits(uint param_1)
{
int local_14;
uint local_10;
int local_c;
local_14 = 0;
local_10 = param_1;
if ((param_1 & 0xffff0000) == 0) {
local_14 = 0x10;
local_10 = param_1 << 0x10;
}
if ((local_10 & 0xff000000) == 0) {
local_14 = local_14 + 8;
local_10 = local_10 << 8;
}
if ((local_10 & 0xf0000000) == 0) {
local_14 = local_14 + 4;
local_10 = local_10 << 4;
}
if ((local_10 & 0xc0000000) == 0) {
local_14 = local_14 + 2;
local_10 = local_10 << 2;
}
if (((local_10 & 0x80000000) == 0) && (local_14 = local_14 + 1, (local_10 & 0x40000000) == 0)) {
local_c = 0x20;
}
else {
local_c = local_14;
}
return local_c;
}
| |
51,206 | hi0bits | eloqsql/strings/dtoa.c | static int hi0bits(register ULong x)
{
register int k= 0;
if (!(x & 0xffff0000))
{
k= 16;
x<<= 16;
}
if (!(x & 0xff000000))
{
k+= 8;
x<<= 8;
}
if (!(x & 0xf0000000))
{
k+= 4;
x<<= 4;
}
if (!(x & 0xc0000000))
{
k+= 2;
x<<= 2;
}
if (!(x & 0x80000000))
{
k++;
if (!(x & 0x40000000))
return 32;
}
return k;
} | O3 | c | hi0bits:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
shll $0x10, %eax
xorl %ecx, %ecx
cmpl $0x10000, %edi # imm = 0x10000
setb %cl
cmovael %edi, %eax
shll $0x4, %ecx
movl %eax, %edx
shll $0x8, %edx
cmpl $0x1000000, %eax # imm = 0x1000000
cmovael %eax, %edx
leal 0x8(%rcx), %eax
cmovael %ecx, %eax
movl %edx, %ecx
shll $0x4, %ecx
cmpl $0x10000000, %edx # imm = 0x10000000
cmovael %edx, %ecx
leal 0x4(%rax), %edx
cmovael %eax, %edx
leal (,%rcx,4), %esi
movl $0x40000000, %eax # imm = 0x40000000
cmpl %eax, %ecx
cmovael %ecx, %esi
leal 0x2(%rdx), %ecx
cmovael %edx, %ecx
leal 0x1(%rcx), %edx
cmpl %eax, %esi
movl $0x20, %eax
cmovael %edx, %eax
testl %esi, %esi
cmovsl %ecx, %eax
popq %rbp
retq
| hi0bits:
push rbp
mov rbp, rsp
mov eax, edi
shl eax, 10h
xor ecx, ecx
cmp edi, 10000h
setb cl
cmovnb eax, edi
shl ecx, 4
mov edx, eax
shl edx, 8
cmp eax, 1000000h
cmovnb edx, eax
lea eax, [rcx+8]
cmovnb eax, ecx
mov ecx, edx
shl ecx, 4
cmp edx, 10000000h
cmovnb ecx, edx
lea edx, [rax+4]
cmovnb edx, eax
lea esi, ds:0[rcx*4]
mov eax, 40000000h
cmp ecx, eax
cmovnb esi, ecx
lea ecx, [rdx+2]
cmovnb ecx, edx
lea edx, [rcx+1]
cmp esi, eax
mov eax, 20h ; ' '
cmovnb eax, edx
test esi, esi
cmovs eax, ecx
pop rbp
retn
| long long hi0bits(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // edx
bool v3; // cf
int v4; // eax
unsigned int v5; // ecx
bool v6; // cf
int v7; // edx
int v8; // esi
bool v9; // cf
unsigned int v10; // ecx
long long result; // rax
v1 = a1 << 16;
if ( a1 >= 0x10000 )
v1 = a1;
v2 = v1 << 8;
v3 = v1 < 0x1000000;
if ( v1 >= 0x1000000 )
v2 = v1;
v4 = 16 * (a1 < 0x10000) + 8;
if ( !v3 )
v4 = 16 * (a1 < 0x10000);
v5 = 16 * v2;
v6 = v2 < 0x10000000;
if ( v2 >= 0x10000000 )
v5 = v2;
v7 = v4 + 4;
if ( !v6 )
v7 = v4;
v8 = 4 * v5;
v9 = v5 < 0x40000000;
if ( v5 >= 0x40000000 )
v8 = v5;
v10 = v7 + 2;
if ( !v9 )
v10 = v7;
result = 32LL;
if ( (unsigned int)v8 >= 0x40000000 )
result = v10 + 1;
if ( v8 < 0 )
return v10;
return result;
}
| hi0bits:
PUSH RBP
MOV RBP,RSP
MOV EAX,EDI
SHL EAX,0x10
XOR ECX,ECX
CMP EDI,0x10000
SETC CL
CMOVNC EAX,EDI
SHL ECX,0x4
MOV EDX,EAX
SHL EDX,0x8
CMP EAX,0x1000000
CMOVNC EDX,EAX
LEA EAX,[RCX + 0x8]
CMOVNC EAX,ECX
MOV ECX,EDX
SHL ECX,0x4
CMP EDX,0x10000000
CMOVNC ECX,EDX
LEA EDX,[RAX + 0x4]
CMOVNC EDX,EAX
LEA ESI,[RCX*0x4]
MOV EAX,0x40000000
CMP ECX,EAX
CMOVNC ESI,ECX
LEA ECX,[RDX + 0x2]
CMOVNC ECX,EDX
LEA EDX,[RCX + 0x1]
CMP ESI,EAX
MOV EAX,0x20
CMOVNC EAX,EDX
TEST ESI,ESI
CMOVS EAX,ECX
POP RBP
RET
|
int hi0bits(uint param_1)
{
uint uVar1;
uint uVar2;
int iVar3;
int iVar4;
uVar2 = param_1 << 0x10;
if (param_1 >= 0x10000) {
uVar2 = param_1;
}
iVar4 = (uint)(param_1 < 0x10000) * 0x10;
uVar1 = uVar2 << 8;
if (0xffffff < uVar2) {
uVar1 = uVar2;
}
iVar3 = iVar4 + 8;
if (0xffffff < uVar2) {
iVar3 = iVar4;
}
uVar2 = uVar1 << 4;
if (0xfffffff < uVar1) {
uVar2 = uVar1;
}
iVar4 = iVar3 + 4;
if (0xfffffff < uVar1) {
iVar4 = iVar3;
}
uVar1 = uVar2 * 4;
if (0x3fffffff < uVar2) {
uVar1 = uVar2;
}
iVar3 = iVar4 + 2;
if (0x3fffffff < uVar2) {
iVar3 = iVar4;
}
iVar4 = 0x20;
if (0x3fffffff < uVar1) {
iVar4 = iVar3 + 1;
}
if ((int)uVar1 < 0) {
iVar4 = iVar3;
}
return iVar4;
}
| |
51,207 | uf_prespace | eloqsql/storage/myisam/mi_packrec.c | static void uf_prespace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
uint spaces;
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
bfill((uchar*) to,spaces,' ');
if (to+spaces != end)
decode_bytes(rec,bit_buff,to+spaces,end);
} | O3 | c | uf_prespace:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsi), %ecx
movl 0x1c(%rdi), %r13d
cmpl %r13d, %ecx
jae 0x846d8
subl %ecx, %r13d
leaq 0x5e6ae(%rip), %rax # 0xe2d50
movq %rbx, -0x30(%rbp)
movl (%rax,%rcx,4), %ebx
andl (%r14), %ebx
movl %r13d, %ecx
shll %cl, %ebx
movq %r14, %rdi
callq 0x832f9
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r14)
movl (%r14), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %ebx, %eax
movq -0x30(%rbp), %rbx
jmp 0x846f2
movl (%r14), %eax
subl %r13d, %ecx
movl %ecx, 0x4(%r14)
shrl %cl, %eax
movl 0x1c(%r15), %ecx
leaq 0x5e661(%rip), %rdx # 0xe2d50
andl (%rdx,%rcx,4), %eax
movl %eax, %edx
leaq (%r12,%rdx), %r13
cmpq %rbx, %r13
jbe 0x84707
movl $0x1, 0x28(%r14)
jmp 0x84738
movq %r12, %rdi
movl $0x20, %esi
callq 0x292c0
cmpq %rbx, %r13
je 0x84738
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x83bea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| uf_prespace_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r12, rdx
mov r14, rsi
mov r15, rdi
mov ecx, [rsi+4]
mov r13d, [rdi+1Ch]
cmp ecx, r13d
jnb short loc_846D8
sub r13d, ecx
lea rax, mask_0
mov [rbp+var_30], rbx
mov ebx, [rax+rcx*4]
and ebx, [r14]
mov ecx, r13d
shl ebx, cl
mov rdi, r14
call fill_buffer_0
mov eax, 20h ; ' '
sub eax, r13d
mov [r14+4], eax
mov eax, [r14]
neg r13d
mov ecx, r13d
shr eax, cl
add eax, ebx
mov rbx, [rbp+var_30]
jmp short loc_846F2
loc_846D8:
mov eax, [r14]
sub ecx, r13d
mov [r14+4], ecx
shr eax, cl
mov ecx, [r15+1Ch]
lea rdx, mask_0
and eax, [rdx+rcx*4]
loc_846F2:
mov edx, eax
lea r13, [r12+rdx]
cmp r13, rbx
jbe short loc_84707
mov dword ptr [r14+28h], 1
jmp short loc_84738
loc_84707:
mov rdi, r12
mov esi, 20h ; ' '
call _memset
cmp r13, rbx
jz short loc_84738
mov rdi, r15
mov rsi, r14
mov rdx, r13
mov rcx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes_0
loc_84738:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long uf_prespace_0(long long a1, unsigned int *a2, long long a3, _BYTE *a4)
{
long long v6; // rcx
unsigned int v7; // r13d
int v8; // r13d
int v9; // ebx
long long result; // rax
unsigned int v11; // eax
unsigned int v12; // ecx
_BYTE *v13; // r13
_BYTE *v14; // [rsp+0h] [rbp-30h]
v6 = a2[1];
v7 = *(_DWORD *)(a1 + 28);
if ( (unsigned int)v6 >= v7 )
{
v11 = *a2;
v12 = v6 - v7;
a2[1] = v12;
result = mask_0[*(unsigned int *)(a1 + 28)] & (v11 >> v12);
}
else
{
v8 = v7 - v6;
v14 = a4;
v9 = (*a2 & mask_0[v6]) << v8;
fill_buffer_0((long long)a2);
a2[1] = 32 - v8;
result = v9 + (*a2 >> -(char)v8);
a4 = v14;
}
v13 = (_BYTE *)(a3 + (unsigned int)result);
if ( v13 <= a4 )
{
result = memset(a3, 32LL, (unsigned int)result);
if ( v13 != a4 )
return (long long)decode_bytes_0(a1, (long long)a2, v13, a4);
}
else
{
a2[10] = 1;
}
return result;
}
| uf_prespace:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R12,RDX
MOV R14,RSI
MOV R15,RDI
MOV ECX,dword ptr [RSI + 0x4]
MOV R13D,dword ptr [RDI + 0x1c]
CMP ECX,R13D
JNC 0x001846d8
SUB R13D,ECX
LEA RAX,[0x1e2d50]
MOV qword ptr [RBP + -0x30],RBX
MOV EBX,dword ptr [RAX + RCX*0x4]
AND EBX,dword ptr [R14]
MOV ECX,R13D
SHL EBX,CL
MOV RDI,R14
CALL 0x001832f9
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R14 + 0x4],EAX
MOV EAX,dword ptr [R14]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD EAX,EBX
MOV RBX,qword ptr [RBP + -0x30]
JMP 0x001846f2
LAB_001846d8:
MOV EAX,dword ptr [R14]
SUB ECX,R13D
MOV dword ptr [R14 + 0x4],ECX
SHR EAX,CL
MOV ECX,dword ptr [R15 + 0x1c]
LEA RDX,[0x1e2d50]
AND EAX,dword ptr [RDX + RCX*0x4]
LAB_001846f2:
MOV EDX,EAX
LEA R13,[R12 + RDX*0x1]
CMP R13,RBX
JBE 0x00184707
MOV dword ptr [R14 + 0x28],0x1
JMP 0x00184738
LAB_00184707:
MOV RDI,R12
MOV ESI,0x20
CALL 0x001292c0
CMP R13,RBX
JZ 0x00184738
MOV RDI,R15
MOV RSI,R14
MOV RDX,R13
MOV RCX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00183bea
LAB_00184738:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void uf_prespace(long param_1,uint *param_2,void *param_3,ulong param_4)
{
ulong uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
byte bVar6;
uVar5 = param_2[1];
uVar2 = *(uint *)(param_1 + 0x1c);
if (uVar5 < uVar2) {
uVar3 = (&mask)[uVar5];
uVar4 = *param_2;
bVar6 = (byte)(uVar2 - uVar5);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar2 - uVar5);
uVar5 = (*param_2 >> (-bVar6 & 0x1f)) + ((uVar3 & uVar4) << (bVar6 & 0x1f));
}
else {
param_2[1] = uVar5 - uVar2;
uVar5 = *param_2 >> ((byte)(uVar5 - uVar2) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
uVar1 = (long)param_3 + (ulong)uVar5;
if (param_4 < uVar1) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)uVar5);
if (uVar1 != param_4) {
decode_bytes(param_1,param_2,uVar1,param_4);
return;
}
}
return;
}
| |
51,208 | translog_filename_by_fileno | eloqsql/storage/maria/ma_loghandler.c | char *translog_filename_by_fileno(uint32 file_no, char *path)
{
char buff[11], *end;
uint length;
DBUG_ENTER("translog_filename_by_fileno");
DBUG_ASSERT(file_no <= 0xfffffff);
/* log_descriptor.directory is already formated */
end= strxmov(path, log_descriptor.directory, "aria_log.0000000", NullS);
length= (uint) (int10_to_str(file_no, buff, 10) - buff);
strmov(end - length +1, buff);
DBUG_PRINT("info", ("Path: '%s' path: %p", path, path));
DBUG_RETURN(path);
} | O3 | c | translog_filename_by_fileno:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %r14d
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
leaq 0x3b70b0(%rip), %rsi # 0x400a98
leaq 0x91738(%rip), %rdx # 0xdb127
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xd810c
movq %rax, %r15
movl %r14d, %edi
leaq -0x2b(%rbp), %r14
movq %r14, %rsi
movl $0xa, %edx
callq 0xd66de
subl %r14d, %eax
subq %rax, %r15
incq %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x29360
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x49a43
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
| translog_filename_by_fileno:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14d, edi
mov rax, fs:28h
mov [rbp+var_20], rax
lea rsi, unk_400A98
lea rdx, aAriaLog0000000; "aria_log.0000000"
mov rdi, rbx
xor ecx, ecx
xor eax, eax
call strxmov
mov r15, rax
mov edi, r14d
lea r14, [rbp+var_2B]
mov rsi, r14
mov edx, 0Ah
call int10_to_str
sub eax, r14d
sub r15, rax
inc r15
mov rdi, r15
mov rsi, r14
call _strcpy
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_49A43
mov rax, rbx
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_49A43:
call ___stack_chk_fail
| long long translog_filename_by_fileno(unsigned int a1, long long a2, long long a3, long long a4, int a5, int a6)
{
long long v6; // r15
int v7; // eax
_BYTE v9[11]; // [rsp+5h] [rbp-2Bh] BYREF
unsigned long long v10; // [rsp+10h] [rbp-20h]
v10 = __readfsqword(0x28u);
v6 = strxmov(a2, (unsigned int)&unk_400A98, (unsigned int)"aria_log.0000000", 0, a5, a6);
v7 = int10_to_str(a1, v9, 10LL);
strcpy(v6 - (v7 - (unsigned int)v9) + 1, v9);
return a2;
}
| translog_filename_by_fileno:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
LEA RSI,[0x500a98]
LEA RDX,[0x1db127]
MOV RDI,RBX
XOR ECX,ECX
XOR EAX,EAX
CALL 0x001d810c
MOV R15,RAX
MOV EDI,R14D
LEA R14,[RBP + -0x2b]
MOV RSI,R14
MOV EDX,0xa
CALL 0x001d66de
SUB EAX,R14D
SUB R15,RAX
INC R15
MOV RDI,R15
MOV RSI,R14
CALL 0x00129360
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00149a43
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00149a43:
CALL 0x00129270
|
int8 translog_filename_by_fileno(int4 param_1,int8 param_2)
{
int iVar1;
long lVar2;
long in_FS_OFFSET;
char local_33 [11];
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
lVar2 = strxmov(param_2,&DAT_00500a98,"aria_log.0000000",0);
iVar1 = int10_to_str(param_1,local_33,10);
strcpy((char *)((lVar2 - (ulong)(uint)(iVar1 - (int)local_33)) + 1),local_33);
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return param_2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
51,209 | plutovg_premultiply_argb | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-utils.h | static inline uint32_t plutovg_premultiply_argb(uint32_t color)
{
uint32_t a = plutovg_alpha(color);
uint32_t r = plutovg_red(color);
uint32_t g = plutovg_green(color);
uint32_t b = plutovg_blue(color);
if(a != 255) {
r = (r * a) / 255;
g = (g * a) / 255;
b = (b * a) / 255;
}
return (a << 24) | (r << 16) | (g << 8) | (b);
} | O0 | c | plutovg_premultiply_argb:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %eax
shrl $0x0, %eax
andl $0xff, %eax
movl %eax, -0x14(%rbp)
cmpl $0xff, -0x8(%rbp)
je 0x65861
movl -0xc(%rbp), %eax
imull -0x8(%rbp), %eax
movl $0xff, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
imull -0x8(%rbp), %eax
movl $0xff, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
imull -0x8(%rbp), %eax
movl $0xff, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
shll $0x18, %eax
movl -0xc(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl -0x10(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
orl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| plutovg_premultiply_argb:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
shr eax, 18h
and eax, 0FFh
mov [rbp+var_8], eax
mov eax, [rbp+var_4]
shr eax, 10h
and eax, 0FFh
mov [rbp+var_C], eax
mov eax, [rbp+var_4]
shr eax, 8
and eax, 0FFh
mov [rbp+var_10], eax
mov eax, [rbp+var_4]
shr eax, 0
and eax, 0FFh
mov [rbp+var_14], eax
cmp [rbp+var_8], 0FFh
jz short loc_65861
mov eax, [rbp+var_C]
imul eax, [rbp+var_8]
mov ecx, 0FFh
xor edx, edx
div ecx
mov [rbp+var_C], eax
mov eax, [rbp+var_10]
imul eax, [rbp+var_8]
mov ecx, 0FFh
xor edx, edx
div ecx
mov [rbp+var_10], eax
mov eax, [rbp+var_14]
imul eax, [rbp+var_8]
mov ecx, 0FFh
xor edx, edx
div ecx
mov [rbp+var_14], eax
loc_65861:
mov eax, [rbp+var_8]
shl eax, 18h
mov ecx, [rbp+var_C]
shl ecx, 10h
or eax, ecx
mov ecx, [rbp+var_10]
shl ecx, 8
or eax, ecx
or eax, [rbp+var_14]
pop rbp
retn
| long long plutovg_premultiply_argb(int a1)
{
unsigned int v2; // [rsp+0h] [rbp-14h]
unsigned int v3; // [rsp+4h] [rbp-10h]
unsigned int v4; // [rsp+8h] [rbp-Ch]
v4 = BYTE2(a1);
v3 = BYTE1(a1);
v2 = (unsigned __int8)a1;
if ( HIBYTE(a1) != 255 )
{
v4 = HIBYTE(a1) * (unsigned int)BYTE2(a1) / 0xFF;
v3 = HIBYTE(a1) * (unsigned int)BYTE1(a1) / 0xFF;
v2 = HIBYTE(a1) * (unsigned int)(unsigned __int8)a1 / 0xFF;
}
return v2 | (v3 << 8) | (v4 << 16) | (HIBYTE(a1) << 24);
}
| plutovg_premultiply_argb:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x18
AND EAX,0xff
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x10
AND EAX,0xff
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x8
AND EAX,0xff
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x0
AND EAX,0xff
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x8],0xff
JZ 0x00165861
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,dword ptr [RBP + -0x8]
MOV ECX,0xff
XOR EDX,EDX
DIV ECX
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RBP + -0x8]
MOV ECX,0xff
XOR EDX,EDX
DIV ECX
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,dword ptr [RBP + -0x8]
MOV ECX,0xff
XOR EDX,EDX
DIV ECX
MOV dword ptr [RBP + -0x14],EAX
LAB_00165861:
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x18
MOV ECX,dword ptr [RBP + -0xc]
SHL ECX,0x10
OR EAX,ECX
MOV ECX,dword ptr [RBP + -0x10]
SHL ECX,0x8
OR EAX,ECX
OR EAX,dword ptr [RBP + -0x14]
POP RBP
RET
|
int1 [16] plutovg_premultiply_argb(uint param_1,int8 param_2,ulong param_3)
{
uint uVar1;
uint uVar2;
int1 auVar3 [16];
int4 local_1c;
int4 local_18;
int4 local_14;
uVar1 = param_1 >> 0x18;
local_14 = param_1 >> 0x10 & 0xff;
local_18 = param_1 >> 8 & 0xff;
local_1c = param_1 & 0xff;
if (uVar1 != 0xff) {
local_14 = (local_14 * uVar1) / 0xff;
local_18 = (local_18 * uVar1) / 0xff;
uVar2 = local_1c * uVar1;
local_1c = uVar2 / 0xff;
param_3 = (ulong)uVar2 % 0xff;
}
auVar3._0_4_ = uVar1 << 0x18 | local_14 << 0x10 | local_18 << 8 | local_1c;
auVar3._4_4_ = 0;
auVar3._8_8_ = param_3;
return auVar3;
}
| |
51,210 | testing::internal::UnitTestImpl::UnshuffleTests() | giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc | void UnitTestImpl::UnshuffleTests() {
for (size_t i = 0; i < test_suites_.size(); i++) {
// Unshuffles the tests in each test suite.
test_suites_[i]->UnshuffleTests();
// Resets the index of each test suite.
test_suite_indices_[i] = static_cast<int>(i);
}
} | O3 | cpp | testing::internal::UnitTestImpl::UnshuffleTests():
movq 0xb8(%rdi), %rax
movq 0xc0(%rdi), %rcx
subq %rax, %rcx
je 0x2ee9d
sarq $0x3, %rcx
movq 0x108(%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movdqa 0x130f8(%rip), %xmm0 # 0x41ed0
movdqa 0x13100(%rip), %xmm1 # 0x41ee0
pcmpeqd %xmm2, %xmm2
movdqa 0x13104(%rip), %xmm3 # 0x41ef0
movq (%rax,%rsi,8), %r8
movq 0x48(%r8), %rdi
movq 0x50(%r8), %r9
subq %rdi, %r9
je 0x2ee8e
sarq $0x2, %r9
cmpq $0x1, %r9
adcq $0x0, %r9
leaq 0x1(%r9), %r8
andq $-0x2, %r8
decq %r9
movq %r9, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
pxor %xmm1, %xmm4
xorl %r9d, %r9d
movdqa %xmm0, %xmm5
movdqa %xmm5, %xmm6
pxor %xmm1, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm4, %xmm7
pcmpeqd %xmm4, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %r10d
notl %r10d
testb $0x1, %r10b
je 0x2ee68
movl %r9d, (%rdi,%r9,4)
pxor %xmm2, %xmm6
pextrw $0x4, %xmm6, %r10d
testb $0x1, %r10b
je 0x2ee81
leal 0x1(%r9), %r10d
movl %r10d, 0x4(%rdi,%r9,4)
addq $0x2, %r9
paddq %xmm3, %xmm5
cmpq %r9, %r8
jne 0x2ee2d
movl %esi, (%rdx,%rsi,4)
incq %rsi
cmpq %rcx, %rsi
jne 0x2edec
retq
| _ZN7testing8internal12UnitTestImpl14UnshuffleTestsEv:
mov rax, [rdi+0B8h]
mov rcx, [rdi+0C0h]
sub rcx, rax
jz locret_2EE9D
sar rcx, 3
mov rdx, [rdi+108h]
cmp rcx, 1
adc rcx, 0
xor esi, esi
movdqa xmm0, cs:xmmword_41ED0
movdqa xmm1, cs:xmmword_41EE0
pcmpeqd xmm2, xmm2
movdqa xmm3, cs:xmmword_41EF0
loc_2EDEC:
mov r8, [rax+rsi*8]
mov rdi, [r8+48h]
mov r9, [r8+50h]
sub r9, rdi
jz loc_2EE8E
sar r9, 2
cmp r9, 1
adc r9, 0
lea r8, [r9+1]
and r8, 0FFFFFFFFFFFFFFFEh
dec r9
movq xmm4, r9
pshufd xmm4, xmm4, 44h ; 'D'
pxor xmm4, xmm1
xor r9d, r9d
movdqa xmm5, xmm0
loc_2EE2D:
movdqa xmm6, xmm5
pxor xmm6, xmm1
movdqa xmm7, xmm6
pcmpgtd xmm7, xmm4
pcmpeqd xmm6, xmm4
pshufd xmm8, xmm6, 0F5h
pand xmm8, xmm7
pshufd xmm6, xmm7, 0F5h
por xmm6, xmm8
movd r10d, xmm6
not r10d
test r10b, 1
jz short loc_2EE68
mov [rdi+r9*4], r9d
loc_2EE68:
pxor xmm6, xmm2
pextrw r10d, xmm6, 4
test r10b, 1
jz short loc_2EE81
lea r10d, [r9+1]
mov [rdi+r9*4+4], r10d
loc_2EE81:
add r9, 2
paddq xmm5, xmm3
cmp r8, r9
jnz short loc_2EE2D
loc_2EE8E:
mov [rdx+rsi*4], esi
inc rsi
cmp rsi, rcx
jnz loc_2EDEC
locret_2EE9D:
retn
| long long testing::internal::UnitTestImpl::UnshuffleTests(testing::internal::UnitTestImpl *this)
{
long long result; // rax
long long v2; // rcx
long long v3; // rdx
long long v4; // rcx
long long v5; // rsi
__m128i si128; // xmm0
__m128i v7; // xmm1
__m128i v8; // xmm3
long long v9; // r8
long long v10; // rdi
long long v11; // r9
long long v12; // r9
unsigned long long v13; // r8
__m128i v14; // xmm4
long long v15; // r9
__m128i v16; // xmm5
__m128i v17; // xmm6
__m128i v18; // xmm7
__m128i v19; // xmm6
result = *((_QWORD *)this + 23);
v2 = *((_QWORD *)this + 24) - result;
if ( v2 )
{
v3 = *((_QWORD *)this + 33);
v4 = (v2 >> 3 == 0) + (v2 >> 3);
v5 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_41ED0);
v7 = _mm_load_si128((const __m128i *)&xmmword_41EE0);
v8 = _mm_load_si128((const __m128i *)&xmmword_41EF0);
do
{
v9 = *(_QWORD *)(result + 8 * v5);
v10 = *(_QWORD *)(v9 + 72);
v11 = *(_QWORD *)(v9 + 80) - v10;
if ( v11 )
{
v12 = (v11 >> 2 == 0) + (v11 >> 2);
v13 = (v12 + 1) & 0xFFFFFFFFFFFFFFFELL;
v14 = _mm_xor_si128(_mm_shuffle_epi32((__m128i)(unsigned long long)(v12 - 1), 68), v7);
v15 = 0LL;
v16 = si128;
do
{
v17 = _mm_xor_si128(v16, v7);
v18 = _mm_cmpgt_epi32(v17, v14);
v19 = _mm_or_si128(
_mm_shuffle_epi32(v18, 245),
_mm_and_si128(_mm_shuffle_epi32(_mm_cmpeq_epi32(v17, v14), 245), v18));
if ( (~_mm_cvtsi128_si32(v19) & 1) != 0 )
*(_DWORD *)(v10 + 4 * v15) = v15;
if ( (_mm_extract_epi16(_mm_xor_si128(v19, (__m128i)-1LL), 4) & 1) != 0 )
*(_DWORD *)(v10 + 4 * v15 + 4) = v15 + 1;
v15 += 2LL;
v16 = _mm_add_epi64(v16, v8);
}
while ( v13 != v15 );
}
*(_DWORD *)(v3 + 4 * v5) = v5;
++v5;
}
while ( v5 != v4 );
}
return result;
}
| UnshuffleTests:
MOV RAX,qword ptr [RDI + 0xb8]
MOV RCX,qword ptr [RDI + 0xc0]
SUB RCX,RAX
JZ 0x0012ee9d
SAR RCX,0x3
MOV RDX,qword ptr [RDI + 0x108]
CMP RCX,0x1
ADC RCX,0x0
XOR ESI,ESI
MOVDQA XMM0,xmmword ptr [0x00141ed0]
MOVDQA XMM1,xmmword ptr [0x00141ee0]
PCMPEQD XMM2,XMM2
MOVDQA XMM3,xmmword ptr [0x00141ef0]
LAB_0012edec:
MOV R8,qword ptr [RAX + RSI*0x8]
MOV RDI,qword ptr [R8 + 0x48]
MOV R9,qword ptr [R8 + 0x50]
SUB R9,RDI
JZ 0x0012ee8e
SAR R9,0x2
CMP R9,0x1
ADC R9,0x0
LEA R8,[R9 + 0x1]
AND R8,-0x2
DEC R9
MOVQ XMM4,R9
PSHUFD XMM4,XMM4,0x44
PXOR XMM4,XMM1
XOR R9D,R9D
MOVDQA XMM5,XMM0
LAB_0012ee2d:
MOVDQA XMM6,XMM5
PXOR XMM6,XMM1
MOVDQA XMM7,XMM6
PCMPGTD XMM7,XMM4
PCMPEQD XMM6,XMM4
PSHUFD XMM8,XMM6,0xf5
PAND XMM8,XMM7
PSHUFD XMM6,XMM7,0xf5
POR XMM6,XMM8
MOVD R10D,XMM6
NOT R10D
TEST R10B,0x1
JZ 0x0012ee68
MOV dword ptr [RDI + R9*0x4],R9D
LAB_0012ee68:
PXOR XMM6,XMM2
PEXTRW R10D,XMM6,0x4
TEST R10B,0x1
JZ 0x0012ee81
LEA R10D,[R9 + 0x1]
MOV dword ptr [RDI + R9*0x4 + 0x4],R10D
LAB_0012ee81:
ADD R9,0x2
PADDQ XMM5,XMM3
CMP R8,R9
JNZ 0x0012ee2d
LAB_0012ee8e:
MOV dword ptr [RDX + RSI*0x4],ESI
INC RSI
CMP RSI,RCX
JNZ 0x0012edec
LAB_0012ee9d:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* testing::internal::UnitTestImpl::UnshuffleTests() */
void __thiscall testing::internal::UnitTestImpl::UnshuffleTests(UnitTestImpl *this)
{
long lVar1;
long lVar2;
long lVar3;
int1 auVar4 [16];
int1 auVar5 [16];
long lVar6;
long lVar7;
long lVar8;
long lVar9;
long lVar10;
long lVar11;
ulong uVar12;
int1 auVar13 [16];
int1 auVar14 [16];
int1 auVar15 [16];
lVar7 = _UNK_00141ef8;
lVar6 = _DAT_00141ef0;
auVar5 = _DAT_00141ee0;
auVar4 = _DAT_00141ed0;
lVar1 = *(long *)(this + 0xb8);
lVar8 = *(long *)(this + 0xc0) - lVar1;
if (lVar8 != 0) {
lVar8 = lVar8 >> 3;
lVar2 = *(long *)(this + 0x108);
lVar9 = 0;
do {
lVar10 = *(long *)(lVar1 + lVar9 * 8);
lVar3 = *(long *)(lVar10 + 0x48);
lVar10 = *(long *)(lVar10 + 0x50) - lVar3;
if (lVar10 != 0) {
lVar10 = lVar10 >> 2;
lVar10 = lVar10 + (ulong)(lVar10 == 0);
lVar11 = lVar10 + -1;
auVar13._8_4_ = (int)lVar11;
auVar13._0_8_ = lVar11;
auVar13._12_4_ = (int)((ulong)lVar11 >> 0x20);
auVar13 = auVar13 ^ auVar5;
uVar12 = 0;
auVar14 = auVar4;
do {
auVar15 = auVar14 ^ auVar5;
if ((bool)(~(auVar13._4_4_ < auVar15._4_4_ ||
auVar13._0_4_ < auVar15._0_4_ && auVar15._4_4_ == auVar13._4_4_) & 1)) {
*(int *)(lVar3 + uVar12 * 4) = (int)uVar12;
}
if (auVar15._12_4_ <= auVar13._12_4_ &&
(auVar15._8_4_ <= auVar13._8_4_ || auVar15._12_4_ != auVar13._12_4_)) {
*(int *)(lVar3 + 4 + uVar12 * 4) = (int)uVar12 + 1;
}
uVar12 = uVar12 + 2;
lVar11 = auVar14._8_8_;
auVar14._0_8_ = auVar14._0_8_ + lVar6;
auVar14._8_8_ = lVar11 + lVar7;
} while ((lVar10 + 1U & 0xfffffffffffffffe) != uVar12);
}
*(int *)(lVar2 + lVar9 * 4) = (int)lVar9;
lVar9 = lVar9 + 1;
} while (lVar9 != lVar8 + (ulong)(lVar8 == 0));
}
return;
}
| |
51,211 | getopt_ull_limit_value | eloqsql/mysys/my_getopt.c | ulonglong getopt_ull_limit_value(ulonglong num, const struct my_option *optp,
my_bool *fix)
{
my_bool adjusted= FALSE;
ulonglong old= num;
char buf1[255], buf2[255];
DBUG_ENTER("getopt_ull_limit_value");
if ((ulonglong) num > (ulonglong) optp->max_value &&
optp->max_value) /* if max value is not set -> no upper limit */
{
num= (ulonglong) optp->max_value;
adjusted= TRUE;
}
switch ((optp->var_type & GET_TYPE_MASK)) {
case GET_UINT:
if (num > (ulonglong) UINT_MAX)
{
num= ((ulonglong) UINT_MAX);
adjusted= TRUE;
}
break;
case GET_ULONG:
#if SIZEOF_LONG < SIZEOF_LONG_LONG
if (num > (ulonglong) ULONG_MAX)
{
num= ((ulonglong) ULONG_MAX);
adjusted= TRUE;
}
#endif
break;
default:
DBUG_ASSERT((optp->var_type & GET_TYPE_MASK) == GET_ULL);
break;
}
if (optp->block_size > 1)
{
num/= (ulonglong) optp->block_size;
num*= (ulonglong) optp->block_size;
}
if (num < (ulonglong) optp->min_value)
{
num= (ulonglong) optp->min_value;
if (old < (ulonglong) optp->min_value)
adjusted= TRUE;
}
if (fix)
*fix= old != num;
else if (adjusted)
my_getopt_error_reporter(WARNING_LEVEL,
"option '%s': unsigned value %s adjusted to %s",
optp->name, ullstr(old, buf1), ullstr(num, buf2));
DBUG_RETURN(num);
} | O0 | c | getopt_ull_limit_value:
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)
movq %rdx, -0x228(%rbp)
movb $0x0, -0x229(%rbp)
movq -0x218(%rbp), %rax
movq %rax, -0x238(%rbp)
movq -0x218(%rbp), %rax
movq -0x220(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jbe 0x3464d
movq -0x220(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x3464d
movq -0x220(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x218(%rbp)
movb $0x1, -0x229(%rbp)
movq -0x220(%rbp), %rax
movq 0x30(%rax), %rax
andl $0x3f, %eax
movq %rax, -0x240(%rbp)
subq $0x4, %rax
je 0x34679
jmp 0x3466a
movq -0x240(%rbp), %rax
subq $0x6, %rax
je 0x3469c
jmp 0x3469e
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, -0x218(%rbp)
jbe 0x3469a
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %rax, -0x218(%rbp)
movb $0x1, -0x229(%rbp)
jmp 0x346a4
jmp 0x346a4
jmp 0x346a0
jmp 0x346a2
jmp 0x346a4
movq -0x220(%rbp), %rax
cmpq $0x1, 0x60(%rax)
jle 0x346ea
movq -0x220(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x218(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x218(%rbp)
movq -0x220(%rbp), %rax
movq 0x60(%rax), %rax
imulq -0x218(%rbp), %rax
movq %rax, -0x218(%rbp)
movq -0x218(%rbp), %rax
movq -0x220(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x3472d
movq -0x220(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x218(%rbp)
movq -0x238(%rbp), %rax
movq -0x220(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x3472b
movb $0x1, -0x229(%rbp)
jmp 0x3472d
cmpq $0x0, -0x228(%rbp)
je 0x3475d
movq -0x238(%rbp), %rax
cmpq -0x218(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x228(%rbp), %rax
movb %cl, (%rax)
jmp 0x347e0
cmpb $0x0, -0x229(%rbp)
je 0x347de
leaq 0x211e63(%rip), %rax # 0x2465d0
movq (%rax), %rax
movq %rax, -0x248(%rbp)
movq -0x220(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x258(%rbp)
movq -0x238(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x82cc0
movq %rax, -0x250(%rbp)
movq -0x218(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x82cc0
movq -0x258(%rbp), %rdx
movq -0x250(%rbp), %rcx
movq -0x248(%rbp), %r9
movq %rax, %r8
movl $0x1, %edi
leaq 0xb9dfc(%rip), %rsi # 0xee5d5
movb $0x0, %al
callq *%r9
jmp 0x347e0
jmp 0x347e2
movq -0x218(%rbp), %rax
movq %rax, -0x260(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x34812
movq -0x260(%rbp), %rax
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
callq 0x29390
nopw (%rax,%rax)
| getopt_ull_limit_value:
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
mov [rbp+var_228], rdx
mov [rbp+var_229], 0
mov rax, [rbp+var_218]
mov [rbp+var_238], rax
mov rax, [rbp+var_218]
mov rcx, [rbp+var_220]
cmp rax, [rcx+50h]
jbe short loc_3464D
mov rax, [rbp+var_220]
cmp qword ptr [rax+50h], 0
jz short loc_3464D
mov rax, [rbp+var_220]
mov rax, [rax+50h]
mov [rbp+var_218], rax
mov [rbp+var_229], 1
loc_3464D:
mov rax, [rbp+var_220]
mov rax, [rax+30h]
and eax, 3Fh
mov [rbp+var_240], rax
sub rax, 4
jz short loc_34679
jmp short $+2
loc_3466A:
mov rax, [rbp+var_240]
sub rax, 6
jz short loc_3469C
jmp short loc_3469E
loc_34679:
mov eax, 0FFFFFFFFh
cmp [rbp+var_218], rax
jbe short loc_3469A
mov eax, 0FFFFFFFFh
mov [rbp+var_218], rax
mov [rbp+var_229], 1
loc_3469A:
jmp short loc_346A4
loc_3469C:
jmp short loc_346A4
loc_3469E:
jmp short $+2
loc_346A0:
jmp short $+2
loc_346A2:
jmp short $+2
loc_346A4:
mov rax, [rbp+var_220]
cmp qword ptr [rax+60h], 1
jle short loc_346EA
mov rax, [rbp+var_220]
mov rcx, [rax+60h]
mov rax, [rbp+var_218]
xor edx, edx
div rcx
mov [rbp+var_218], rax
mov rax, [rbp+var_220]
mov rax, [rax+60h]
imul rax, [rbp+var_218]
mov [rbp+var_218], rax
loc_346EA:
mov rax, [rbp+var_218]
mov rcx, [rbp+var_220]
cmp rax, [rcx+48h]
jnb short loc_3472D
mov rax, [rbp+var_220]
mov rax, [rax+48h]
mov [rbp+var_218], rax
mov rax, [rbp+var_238]
mov rcx, [rbp+var_220]
cmp rax, [rcx+48h]
jnb short loc_3472B
mov [rbp+var_229], 1
loc_3472B:
jmp short $+2
loc_3472D:
cmp [rbp+var_228], 0
jz short loc_3475D
mov rax, [rbp+var_238]
cmp rax, [rbp+var_218]
setnz al
and al, 1
movzx eax, al
mov cl, al
mov rax, [rbp+var_228]
mov [rax], cl
jmp loc_347E0
loc_3475D:
cmp [rbp+var_229], 0
jz short loc_347DE
lea rax, my_getopt_error_reporter
mov rax, [rax]
mov [rbp+var_248], rax
mov rax, [rbp+var_220]
mov rax, [rax]
mov [rbp+var_258], rax
mov rdi, [rbp+var_238]
lea rsi, [rbp+var_110]
call ullstr
mov [rbp+var_250], rax
mov rdi, [rbp+var_218]
lea rsi, [rbp+var_210]
call ullstr
mov rdx, [rbp+var_258]
mov rcx, [rbp+var_250]
mov r9, [rbp+var_248]
mov r8, rax
mov edi, 1
lea rsi, aOptionSUnsigne; "option '%s': unsigned value %s adjusted"...
mov al, 0
call r9
loc_347DE:
jmp short $+2
loc_347E0:
jmp short $+2
loc_347E2:
mov rax, [rbp+var_218]
mov [rbp+var_260], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_34812
mov rax, [rbp+var_260]
add rsp, 260h
pop rbp
retn
loc_34812:
call ___stack_chk_fail
| unsigned long long getopt_ull_limit_value(unsigned long long a1, long long a2, bool *a3)
{
const char *v3; // rax
const char *v5; // [rsp+8h] [rbp-258h]
const char *v6; // [rsp+10h] [rbp-250h]
long long (*v7)(int, long long, ...); // [rsp+18h] [rbp-248h]
char v8; // [rsp+37h] [rbp-229h]
unsigned long long v9; // [rsp+48h] [rbp-218h]
_BYTE v10[256]; // [rsp+50h] [rbp-210h] BYREF
_BYTE v11[264]; // [rsp+150h] [rbp-110h] BYREF
unsigned long long v12; // [rsp+258h] [rbp-8h]
v12 = __readfsqword(0x28u);
v9 = a1;
v8 = 0;
if ( a1 > *(_QWORD *)(a2 + 80) && *(_QWORD *)(a2 + 80) )
{
v9 = *(_QWORD *)(a2 + 80);
v8 = 1;
}
if ( (*(_QWORD *)(a2 + 48) & 0x3FLL) == 4 && v9 > 0xFFFFFFFF )
{
v9 = 0xFFFFFFFFLL;
v8 = 1;
}
if ( *(long long *)(a2 + 96) > 1 )
v9 = v9 / *(_QWORD *)(a2 + 96) * *(_QWORD *)(a2 + 96);
if ( v9 < *(_QWORD *)(a2 + 72) )
{
v9 = *(_QWORD *)(a2 + 72);
if ( a1 < v9 )
v8 = 1;
}
if ( a3 )
{
*a3 = a1 != v9;
}
else if ( v8 )
{
v7 = my_getopt_error_reporter;
v5 = *(const char **)a2;
v6 = (const char *)ullstr(a1, v11);
v3 = (const char *)ullstr(v9, v10);
v7(1, (long long)"option '%s': unsigned value %s adjusted to %s", v5, v6, v3);
}
return v9;
}
| getopt_ull_limit_value:
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
MOV qword ptr [RBP + -0x228],RDX
MOV byte ptr [RBP + -0x229],0x0
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x238],RAX
MOV RAX,qword ptr [RBP + -0x218]
MOV RCX,qword ptr [RBP + -0x220]
CMP RAX,qword ptr [RCX + 0x50]
JBE 0x0013464d
MOV RAX,qword ptr [RBP + -0x220]
CMP qword ptr [RAX + 0x50],0x0
JZ 0x0013464d
MOV RAX,qword ptr [RBP + -0x220]
MOV RAX,qword ptr [RAX + 0x50]
MOV qword ptr [RBP + -0x218],RAX
MOV byte ptr [RBP + -0x229],0x1
LAB_0013464d:
MOV RAX,qword ptr [RBP + -0x220]
MOV RAX,qword ptr [RAX + 0x30]
AND EAX,0x3f
MOV qword ptr [RBP + -0x240],RAX
SUB RAX,0x4
JZ 0x00134679
JMP 0x0013466a
LAB_0013466a:
MOV RAX,qword ptr [RBP + -0x240]
SUB RAX,0x6
JZ 0x0013469c
JMP 0x0013469e
LAB_00134679:
MOV EAX,0xffffffff
CMP qword ptr [RBP + -0x218],RAX
JBE 0x0013469a
MOV EAX,0xffffffff
MOV qword ptr [RBP + -0x218],RAX
MOV byte ptr [RBP + -0x229],0x1
LAB_0013469a:
JMP 0x001346a4
LAB_0013469c:
JMP 0x001346a4
LAB_0013469e:
JMP 0x001346a0
LAB_001346a0:
JMP 0x001346a2
LAB_001346a2:
JMP 0x001346a4
LAB_001346a4:
MOV RAX,qword ptr [RBP + -0x220]
CMP qword ptr [RAX + 0x60],0x1
JLE 0x001346ea
MOV RAX,qword ptr [RBP + -0x220]
MOV RCX,qword ptr [RAX + 0x60]
MOV RAX,qword ptr [RBP + -0x218]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x218],RAX
MOV RAX,qword ptr [RBP + -0x220]
MOV RAX,qword ptr [RAX + 0x60]
IMUL RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x218],RAX
LAB_001346ea:
MOV RAX,qword ptr [RBP + -0x218]
MOV RCX,qword ptr [RBP + -0x220]
CMP RAX,qword ptr [RCX + 0x48]
JNC 0x0013472d
MOV RAX,qword ptr [RBP + -0x220]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x218],RAX
MOV RAX,qword ptr [RBP + -0x238]
MOV RCX,qword ptr [RBP + -0x220]
CMP RAX,qword ptr [RCX + 0x48]
JNC 0x0013472b
MOV byte ptr [RBP + -0x229],0x1
LAB_0013472b:
JMP 0x0013472d
LAB_0013472d:
CMP qword ptr [RBP + -0x228],0x0
JZ 0x0013475d
MOV RAX,qword ptr [RBP + -0x238]
CMP RAX,qword ptr [RBP + -0x218]
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x228]
MOV byte ptr [RAX],CL
JMP 0x001347e0
LAB_0013475d:
CMP byte ptr [RBP + -0x229],0x0
JZ 0x001347de
LEA RAX,[0x3465d0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x248],RAX
MOV RAX,qword ptr [RBP + -0x220]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x258],RAX
MOV RDI,qword ptr [RBP + -0x238]
LEA RSI,[RBP + -0x110]
CALL 0x00182cc0
MOV qword ptr [RBP + -0x250],RAX
MOV RDI,qword ptr [RBP + -0x218]
LEA RSI,[RBP + -0x210]
CALL 0x00182cc0
MOV RDX,qword ptr [RBP + -0x258]
MOV RCX,qword ptr [RBP + -0x250]
MOV R9,qword ptr [RBP + -0x248]
MOV R8,RAX
MOV EDI,0x1
LEA RSI,[0x1ee5d5]
MOV AL,0x0
CALL R9
LAB_001347de:
JMP 0x001347e0
LAB_001347e0:
JMP 0x001347e2
LAB_001347e2:
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x260],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00134812
MOV RAX,qword ptr [RBP + -0x260]
ADD RSP,0x260
POP RBP
RET
LAB_00134812:
CALL 0x00129390
|
ulong getopt_ull_limit_value(ulong param_1,int8 *param_2,ulong param_3)
{
int8 uVar1;
bool bVar2;
int *puVar3;
int8 uVar4;
int8 uVar5;
ulong uVar6;
long in_FS_OFFSET;
ulong local_220;
int1 local_218 [256];
int1 local_118 [264];
long local_10;
puVar3 = my_getopt_error_reporter;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
bVar2 = false;
local_220 = param_1;
if (((ulong)param_2[10] < param_1) && (param_2[10] != 0)) {
local_220 = param_2[10];
bVar2 = true;
}
if ((((uint)param_2[6] & 0x3f) == 4) && (0xffffffff < local_220)) {
local_220 = 0xffffffff;
bVar2 = true;
}
uVar6 = param_3;
if (1 < (long)param_2[0xc]) {
uVar6 = local_220 % (ulong)param_2[0xc];
local_220 = param_2[0xc] * (local_220 / (ulong)param_2[0xc]);
}
if ((local_220 < (ulong)param_2[9]) && (local_220 = param_2[9], param_1 < (ulong)param_2[9])) {
bVar2 = true;
}
if (param_3 == 0) {
if (bVar2) {
uVar1 = *param_2;
uVar4 = ullstr(param_1,local_118,uVar6);
uVar5 = ullstr(local_220,local_218);
(*(code *)puVar3)(1,"option \'%s\': unsigned value %s adjusted to %s",uVar1,uVar4,uVar5);
}
}
else {
*(bool *)param_3 = param_1 != local_220;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_220;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
51,212 | js_std_add_helpers | bluesky950520[P]quickjs/quickjs-libc.c | void js_std_add_helpers(JSContext *ctx, int argc, char **argv)
{
JSValue global_obj, console, args;
int i;
/* XXX: should these global definitions be enumerable? */
global_obj = JS_GetGlobalObject(ctx);
console = JS_NewObject(ctx);
JS_SetPropertyStr(ctx, console, "log",
JS_NewCFunction(ctx, js_print, "log", 1));
JS_SetPropertyStr(ctx, global_obj, "console", console);
/* same methods as the mozilla JS shell */
if (argc >= 0) {
args = JS_NewArray(ctx);
for(i = 0; i < argc; i++) {
JS_SetPropertyUint32(ctx, args, i, JS_NewString(ctx, argv[i]));
}
JS_SetPropertyStr(ctx, global_obj, "scriptArgs", args);
}
JS_SetPropertyStr(ctx, global_obj, "print",
JS_NewCFunction(ctx, js_print, "print", 1));
JS_FreeValue(ctx, global_obj);
} | O1 | c | js_std_add_helpers:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x20(%rsp)
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
callq 0x216f7
movq %rax, %r12
movq %rdx, %r15
movq %rbx, %rdi
callq 0x203c6
movq %rax, %r14
movq %rdx, %r13
leaq 0x13b(%rip), %rsi # 0x1442c
leaq 0x85f6c(%rip), %rbp # 0x9a264
movq %rbx, %rdi
movq %rbp, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x203dc
movq %rdx, %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movl 0x4(%rsp), %ebp
movq %rax, %r8
callq 0x24814
leaq 0x85f38(%rip), %rcx # 0x9a268
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %r8
movq %r13, %r9
callq 0x24814
testl %ebp, %ebp
js 0x143d5
movq %r15, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %rbx, %rdi
callq 0xf664
movq %rax, %r13
movq %rdx, 0x8(%rsp)
testl %ebp, %ebp
movq 0x20(%rsp), %r14
je 0x143ae
movl %ebp, %r12d
xorl %ebp, %ebp
movq (%r14,%rbp,8), %r15
movq %r15, %rdi
callq 0xe240
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1f2f3
movq %rdx, %r9
movq %rbx, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
movl %ebp, %ecx
movq %rax, %r8
callq 0x240ff
incq %rbp
cmpq %rbp, %r12
jne 0x14374
leaq 0x85ebb(%rip), %rcx # 0x9a270
movq %rbx, %rdi
movq 0x18(%rsp), %r12
movq %r12, %rsi
movq 0x10(%rsp), %r15
movq %r15, %rdx
movq %r13, %r8
movq 0x8(%rsp), %r9
callq 0x24814
leaq 0x50(%rip), %rsi # 0x1442c
leaq 0x85e98(%rip), %r14 # 0x9a27b
movq %rbx, %rdi
movq %r14, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x203dc
movq %rdx, %r9
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x24814
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1cc9f
| js_std_add_helpers:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_38], rdx
mov [rsp+58h+var_54], esi
mov rbx, rdi
call JS_GetGlobalObject
mov r12, rax
mov r15, rdx
mov rdi, rbx
call JS_NewObject
mov r14, rax
mov r13, rdx
lea rsi, js_print
lea rbp, aLog_0; "log"
mov rdi, rbx
mov rdx, rbp
mov ecx, 1
xor r8d, r8d
xor r9d, r9d
call JS_NewCFunction2
mov r9, rdx
mov rdi, rbx
mov rsi, r14
mov rdx, r13
mov rcx, rbp
mov ebp, [rsp+58h+var_54]
mov r8, rax
call JS_SetPropertyStr
lea rcx, aConsole; "console"
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov r8, r14
mov r9, r13
call JS_SetPropertyStr
test ebp, ebp
js loc_143D5
mov [rsp+58h+var_48], r15
mov [rsp+58h+var_40], r12
mov rdi, rbx
call JS_NewArray
mov r13, rax
mov [rsp+58h+var_50], rdx
test ebp, ebp
mov r14, [rsp+58h+var_38]
jz short loc_143AE
mov r12d, ebp
xor ebp, ebp
loc_14374:
mov r15, [r14+rbp*8]
mov rdi, r15
call _strlen
mov rdi, rbx
mov rsi, r15
mov rdx, rax
call JS_NewStringLen
mov r9, rdx
mov rdi, rbx
mov rsi, r13
mov rdx, [rsp+58h+var_50]
mov ecx, ebp
mov r8, rax
call JS_SetPropertyUint32
inc rbp
cmp r12, rbp
jnz short loc_14374
loc_143AE:
lea rcx, aScriptargs; "scriptArgs"
mov rdi, rbx
mov r12, [rsp+58h+var_40]
mov rsi, r12
mov r15, [rsp+58h+var_48]
mov rdx, r15
mov r8, r13
mov r9, [rsp+58h+var_50]
call JS_SetPropertyStr
loc_143D5:
lea rsi, js_print
lea r14, aPrint; "print"
mov rdi, rbx
mov rdx, r14
mov ecx, 1
xor r8d, r8d
xor r9d, r9d
call JS_NewCFunction2
mov r9, rdx
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov rcx, r14
mov r8, rax
call JS_SetPropertyStr
mov rdi, rbx
mov rsi, r12
mov rdx, r15
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_FreeValue
| long long js_std_add_helpers(long long a1, int a2, long long a3)
{
long long GlobalObject; // r12
long long v4; // rdx
long long v5; // r15
long long v6; // r14
long long v7; // rdx
long long v8; // r13
long long v9; // rax
long long v10; // rdx
long long v11; // r13
long long v12; // rdx
long long i; // rbp
long long v14; // r15
long long v15; // rax
long long v16; // rax
long long v17; // rdx
long long v18; // rax
long long v19; // rdx
long long v21; // [rsp+8h] [rbp-50h]
long long v22; // [rsp+10h] [rbp-48h]
GlobalObject = JS_GetGlobalObject();
v5 = v4;
v6 = JS_NewObject(a1);
v8 = v7;
v9 = JS_NewCFunction2(a1, js_print, "log", 1LL, 0LL, 0LL);
JS_SetPropertyStr(a1, v6, v8, "log", v9, v10);
JS_SetPropertyStr(a1, GlobalObject, v5, "console", v6, v8);
if ( a2 >= 0 )
{
v22 = v5;
v11 = JS_NewArray(a1);
v21 = v12;
if ( a2 )
{
for ( i = 0LL; i != a2; JS_SetPropertyUint32(a1, v11, v21, (unsigned int)i++, v16, v17) )
{
v14 = *(_QWORD *)(a3 + 8 * i);
v15 = strlen(v14);
v16 = JS_NewStringLen(a1, v14, v15);
}
}
v5 = v22;
JS_SetPropertyStr(a1, GlobalObject, v22, "scriptArgs", v11, v21);
}
v18 = JS_NewCFunction2(a1, js_print, "print", 1LL, 0LL, 0LL);
JS_SetPropertyStr(a1, GlobalObject, v5, "print", v18, v19);
return JS_FreeValue(a1, GlobalObject, v5);
}
| js_std_add_helpers:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDX
MOV dword ptr [RSP + 0x4],ESI
MOV RBX,RDI
CALL 0x001216f7
MOV R12,RAX
MOV R15,RDX
MOV RDI,RBX
CALL 0x001203c6
MOV R14,RAX
MOV R13,RDX
LEA RSI,[0x11442c]
LEA RBP,[0x19a264]
MOV RDI,RBX
MOV RDX,RBP
MOV ECX,0x1
XOR R8D,R8D
XOR R9D,R9D
CALL 0x001203dc
MOV R9,RDX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R13
MOV RCX,RBP
MOV EBP,dword ptr [RSP + 0x4]
MOV R8,RAX
CALL 0x00124814
LEA RCX,[0x19a268]
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
MOV R8,R14
MOV R9,R13
CALL 0x00124814
TEST EBP,EBP
JS 0x001143d5
MOV qword ptr [RSP + 0x10],R15
MOV qword ptr [RSP + 0x18],R12
MOV RDI,RBX
CALL 0x0010f664
MOV R13,RAX
MOV qword ptr [RSP + 0x8],RDX
TEST EBP,EBP
MOV R14,qword ptr [RSP + 0x20]
JZ 0x001143ae
MOV R12D,EBP
XOR EBP,EBP
LAB_00114374:
MOV R15,qword ptr [R14 + RBP*0x8]
MOV RDI,R15
CALL 0x0010e240
MOV RDI,RBX
MOV RSI,R15
MOV RDX,RAX
CALL 0x0011f2f3
MOV R9,RDX
MOV RDI,RBX
MOV RSI,R13
MOV RDX,qword ptr [RSP + 0x8]
MOV ECX,EBP
MOV R8,RAX
CALL 0x001240ff
INC RBP
CMP R12,RBP
JNZ 0x00114374
LAB_001143ae:
LEA RCX,[0x19a270]
MOV RDI,RBX
MOV R12,qword ptr [RSP + 0x18]
MOV RSI,R12
MOV R15,qword ptr [RSP + 0x10]
MOV RDX,R15
MOV R8,R13
MOV R9,qword ptr [RSP + 0x8]
CALL 0x00124814
LAB_001143d5:
LEA RSI,[0x11442c]
LEA R14,[0x19a27b]
MOV RDI,RBX
MOV RDX,R14
MOV ECX,0x1
XOR R8D,R8D
XOR R9D,R9D
CALL 0x001203dc
MOV R9,RDX
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
MOV R8,RAX
CALL 0x00124814
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0011cc9f
|
void js_std_add_helpers(int8 param_1,uint param_2,long param_3)
{
char *__s;
int8 uVar1;
size_t sVar2;
int8 uVar3;
ulong uVar4;
int1 auVar5 [16];
int1 auVar6 [16];
auVar5 = JS_GetGlobalObject();
uVar3 = auVar5._8_8_;
uVar1 = auVar5._0_8_;
auVar5 = JS_NewObject(param_1);
auVar6 = JS_NewCFunction2(param_1,js_print,&DAT_0019a264,1,0,0);
JS_SetPropertyStr(param_1,auVar5._0_8_,auVar5._8_8_,&DAT_0019a264,auVar6._0_8_,auVar6._8_8_);
JS_SetPropertyStr(param_1,uVar1,uVar3,"console",auVar5._0_8_,auVar5._8_8_);
if (-1 < (int)param_2) {
auVar5 = JS_NewArray(param_1);
if (param_2 != 0) {
uVar4 = 0;
do {
__s = *(char **)(param_3 + uVar4 * 8);
sVar2 = strlen(__s);
auVar6 = JS_NewStringLen(param_1,__s,sVar2);
JS_SetPropertyUint32
(param_1,auVar5._0_8_,auVar5._8_8_,uVar4 & 0xffffffff,auVar6._0_8_,auVar6._8_8_);
uVar4 = uVar4 + 1;
} while (param_2 != uVar4);
}
JS_SetPropertyStr(param_1,uVar1,uVar3,"scriptArgs",auVar5._0_8_,auVar5._8_8_);
}
auVar5 = JS_NewCFunction2(param_1,js_print,"print",1,0,0);
JS_SetPropertyStr(param_1,uVar1,uVar3,"print",auVar5._0_8_,auVar5._8_8_);
JS_FreeValue(param_1,uVar1,uVar3);
return;
}
| |
51,213 | js_std_add_helpers | bluesky950520[P]quickjs/quickjs-libc.c | void js_std_add_helpers(JSContext *ctx, int argc, char **argv)
{
JSValue global_obj, console, args;
int i;
/* XXX: should these global definitions be enumerable? */
global_obj = JS_GetGlobalObject(ctx);
console = JS_NewObject(ctx);
JS_SetPropertyStr(ctx, console, "log",
JS_NewCFunction(ctx, js_print, "log", 1));
JS_SetPropertyStr(ctx, global_obj, "console", console);
/* same methods as the mozilla JS shell */
if (argc >= 0) {
args = JS_NewArray(ctx);
for(i = 0; i < argc; i++) {
JS_SetPropertyUint32(ctx, args, i, JS_NewString(ctx, argv[i]));
}
JS_SetPropertyStr(ctx, global_obj, "scriptArgs", args);
}
JS_SetPropertyStr(ctx, global_obj, "print",
JS_NewCFunction(ctx, js_print, "print", 1));
JS_FreeValue(ctx, global_obj);
} | O2 | c | js_std_add_helpers:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
callq 0x1b8b4
movq %rax, %r15
movq %rdx, %rbp
movq %rbx, %rdi
callq 0x1a74d
movq %rax, %r14
movq %rdx, %r13
leaq 0x71ee4(%rip), %rsi # 0x81210
movq %rbx, %rdi
callq 0xf429
movq %rdx, %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
leaq 0x71ec9(%rip), %rcx # 0x81210
movq %rax, %r8
callq 0x1e5d5
leaq 0x71ebe(%rip), %rcx # 0x81214
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r14, %r8
movl 0x4(%rsp), %r14d
movq %r13, %r9
callq 0x1e5d5
testl %r14d, %r14d
js 0xf3e4
movq %rbp, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %rbx, %rdi
callq 0x1a73f
movq %rax, %r13
movq %rdx, %rbp
movl %r14d, %r15d
xorl %r14d, %r14d
cmpq %r14, %r15
je 0xf3bf
movq (%r12,%r14,8), %rsi
movq %rbx, %rdi
callq 0xee11
movq %rdx, %r9
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movl %r14d, %ecx
movq %rax, %r8
callq 0x1e167
incq %r14
jmp 0xf392
leaq 0x71e56(%rip), %rcx # 0x8121c
movq %rbx, %rdi
movq 0x10(%rsp), %r15
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %r8
movq %rbp, %r9
movq %rdx, %rbp
callq 0x1e5d5
leaq 0x71e3c(%rip), %r14 # 0x81227
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf429
movq %rdx, %r9
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x1e5d5
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x174a2
| js_std_add_helpers:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdx
mov [rsp+48h+var_44], esi
mov rbx, rdi
call JS_GetGlobalObject
mov r15, rax
mov rbp, rdx
mov rdi, rbx
call JS_NewObject
mov r14, rax
mov r13, rdx
lea rsi, aLog_0; "log"
mov rdi, rbx
call JS_NewCFunction
mov r9, rdx
mov rdi, rbx
mov rsi, r14
mov rdx, r13
lea rcx, aLog_0; "log"
mov r8, rax
call JS_SetPropertyStr
lea rcx, aConsole; "console"
mov rdi, rbx
mov rsi, r15
mov rdx, rbp
mov r8, r14
mov r14d, [rsp+48h+var_44]
mov r9, r13
call JS_SetPropertyStr
test r14d, r14d
js short loc_F3E4
mov [rsp+48h+var_40], rbp
mov [rsp+48h+var_38], r15
mov rdi, rbx
call JS_NewArray
mov r13, rax
mov rbp, rdx
mov r15d, r14d
xor r14d, r14d
loc_F392:
cmp r15, r14
jz short loc_F3BF
mov rsi, [r12+r14*8]
mov rdi, rbx
call JS_NewString
mov r9, rdx
mov rdi, rbx
mov rsi, r13
mov rdx, rbp
mov ecx, r14d
mov r8, rax
call JS_SetPropertyUint32
inc r14
jmp short loc_F392
loc_F3BF:
lea rcx, aScriptargs; "scriptArgs"
mov rdi, rbx
mov r15, [rsp+48h+var_38]
mov rsi, r15
mov rdx, [rsp+48h+var_40]
mov r8, r13
mov r9, rbp
mov rbp, rdx
call JS_SetPropertyStr
loc_F3E4:
lea r14, aPrint; "print"
mov rdi, rbx
mov rsi, r14
call JS_NewCFunction
mov r9, rdx
mov rdi, rbx
mov rsi, r15
mov rdx, rbp
mov rcx, r14
mov r8, rax
call JS_SetPropertyStr
mov rdi, rbx
mov rsi, r15
mov rdx, rbp
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_FreeValue
| long long js_std_add_helpers(long long a1, int a2, long long a3)
{
long long GlobalObject; // r15
long long v5; // rdx
long long v6; // rbp
long long v7; // r14
long long v8; // rdx
long long v9; // r13
long long v10; // rax
long long v11; // rdx
long long v12; // r13
long long v13; // rdx
long long v14; // rbp
long long i; // r14
long long v16; // rax
long long v17; // rdx
long long v18; // r9
long long v19; // rax
long long v20; // rdx
long long v22; // [rsp+8h] [rbp-40h]
GlobalObject = JS_GetGlobalObject();
v6 = v5;
v7 = JS_NewObject(a1);
v9 = v8;
v10 = JS_NewCFunction(a1, "log");
JS_SetPropertyStr(a1, v7, v9, "log", v10, v11);
JS_SetPropertyStr(a1, GlobalObject, v6, "console", v7, v9);
if ( a2 >= 0 )
{
v22 = v6;
v12 = JS_NewArray(a1);
v14 = v13;
for ( i = 0LL; a2 != i; ++i )
{
v16 = JS_NewString(a1, *(_QWORD *)(a3 + 8 * i));
JS_SetPropertyUint32(a1, v12, v14, (unsigned int)i, v16, v17);
}
v18 = v14;
v6 = v22;
JS_SetPropertyStr(a1, GlobalObject, v22, "scriptArgs", v12, v18);
}
v19 = JS_NewCFunction(a1, "print");
JS_SetPropertyStr(a1, GlobalObject, v6, "print", v19, v20);
return JS_FreeValue(a1, GlobalObject, v6);
}
| js_std_add_helpers:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDX
MOV dword ptr [RSP + 0x4],ESI
MOV RBX,RDI
CALL 0x0011b8b4
MOV R15,RAX
MOV RBP,RDX
MOV RDI,RBX
CALL 0x0011a74d
MOV R14,RAX
MOV R13,RDX
LEA RSI,[0x181210]
MOV RDI,RBX
CALL 0x0010f429
MOV R9,RDX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R13
LEA RCX,[0x181210]
MOV R8,RAX
CALL 0x0011e5d5
LEA RCX,[0x181214]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,RBP
MOV R8,R14
MOV R14D,dword ptr [RSP + 0x4]
MOV R9,R13
CALL 0x0011e5d5
TEST R14D,R14D
JS 0x0010f3e4
MOV qword ptr [RSP + 0x8],RBP
MOV qword ptr [RSP + 0x10],R15
MOV RDI,RBX
CALL 0x0011a73f
MOV R13,RAX
MOV RBP,RDX
MOV R15D,R14D
XOR R14D,R14D
LAB_0010f392:
CMP R15,R14
JZ 0x0010f3bf
MOV RSI,qword ptr [R12 + R14*0x8]
MOV RDI,RBX
CALL 0x0010ee11
MOV R9,RDX
MOV RDI,RBX
MOV RSI,R13
MOV RDX,RBP
MOV ECX,R14D
MOV R8,RAX
CALL 0x0011e167
INC R14
JMP 0x0010f392
LAB_0010f3bf:
LEA RCX,[0x18121c]
MOV RDI,RBX
MOV R15,qword ptr [RSP + 0x10]
MOV RSI,R15
MOV RDX,qword ptr [RSP + 0x8]
MOV R8,R13
MOV R9,RBP
MOV RBP,RDX
CALL 0x0011e5d5
LAB_0010f3e4:
LEA R14,[0x181227]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010f429
MOV R9,RDX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,RBP
MOV RCX,R14
MOV R8,RAX
CALL 0x0011e5d5
MOV RDI,RBX
MOV RSI,R15
MOV RDX,RBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001174a2
|
void js_std_add_helpers(int8 param_1,uint param_2,long param_3)
{
int8 uVar1;
int8 uVar2;
ulong uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
auVar4 = JS_GetGlobalObject();
uVar2 = auVar4._8_8_;
uVar1 = auVar4._0_8_;
auVar4 = JS_NewObject(param_1);
auVar5 = JS_NewCFunction(param_1,&DAT_00181210);
JS_SetPropertyStr(param_1,auVar4._0_8_,auVar4._8_8_,&DAT_00181210,auVar5._0_8_,auVar5._8_8_);
JS_SetPropertyStr(param_1,uVar1,uVar2,"console",auVar4._0_8_,auVar4._8_8_);
if (-1 < (int)param_2) {
auVar4 = JS_NewArray(param_1);
for (uVar3 = 0; param_2 != uVar3; uVar3 = uVar3 + 1) {
auVar5 = JS_NewString(param_1,*(int8 *)(param_3 + uVar3 * 8));
JS_SetPropertyUint32
(param_1,auVar4._0_8_,auVar4._8_8_,uVar3 & 0xffffffff,auVar5._0_8_,auVar5._8_8_);
}
JS_SetPropertyStr(param_1,uVar1,uVar2,"scriptArgs",auVar4._0_8_,auVar4._8_8_);
}
auVar4 = JS_NewCFunction(param_1,"print");
JS_SetPropertyStr(param_1,uVar1,uVar2,"print",auVar4._0_8_,auVar4._8_8_);
JS_FreeValue(param_1,uVar1,uVar2);
return;
}
| |
51,214 | evmone::advanced::Instruction const* evmone::advanced::(anonymous namespace)::op<&void evmone::advanced::instr::impl<(evmone::Opcode)9, &evmone::instr::core::mulmod(evmone::StackTop)>(evmone::advanced::AdvancedExecutionState&)>(evmone::advanced::Instruction const*, evmone::advanced::AdvancedExecutionState&) | corpus-core[P]colibri-stateless/build_O1/_deps/evmone_external-src/lib/evmone/advanced_instructions.cpp | const Instruction* op(const Instruction* instr, AdvancedExecutionState& state) noexcept
{
InstrFn(state);
return ++instr;
} | O1 | cpp | evmone::advanced::Instruction const* evmone::advanced::(anonymous namespace)::op<&void evmone::advanced::instr::impl<(evmone::Opcode)9, &evmone::instr::core::mulmod(evmone::StackTop)>(evmone::advanced::AdvancedExecutionState&)>(evmone::advanced::Instruction const*, evmone::advanced::AdvancedExecutionState&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x228(%rsi), %r15
movq %rsi, %rdi
callq 0x432cc
movl 0x20(%rax), %ecx
movq 0x24(%rax), %rdx
movq 0x2c(%rax), %rax
bswapq %rax
bswapq %rdx
bswapl %ecx
movq %rax, 0x20(%r15)
movq %rdx, 0x28(%r15)
movq %rcx, 0x30(%r15)
movq $0x0, 0x38(%r15)
addq $0x20, 0x228(%rbx)
addq $0x10, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| _ZN6evmone8advanced12_GLOBAL__N_12opIXadL_ZNS0_5instr4implILNS_6OpcodeE50EXadL_ZNS_5instr4core6originENS_8StackTopERNS_14ExecutionStateEEEEEvRNS0_22AdvancedExecutionStateEEEEEPKNS0_11InstructionESF_SC_:
push r15
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov r15, [rsi+228h]
mov rdi, rsi; this
call _ZN6evmone14ExecutionState14get_tx_contextEv; evmone::ExecutionState::get_tx_context(void)
mov ecx, [rax+20h]
mov rdx, [rax+24h]
mov rax, [rax+2Ch]
bswap rax
bswap rdx
bswap ecx
mov [r15+20h], rax
mov [r15+28h], rdx
mov [r15+30h], rcx
mov qword ptr [r15+38h], 0
add qword ptr [rbx+228h], 20h ; ' '
add r14, 10h
mov rax, r14
pop rbx
pop r14
pop r15
retn
| long long evmone::advanced::`anonymous namespace'::op<&void evmone::advanced::instr::impl<(evmone::Opcode)50,&evmone::instr::core::origin>>(
long long a1,
evmone::ExecutionState *a2)
{
_QWORD *v2; // r15
long long tx_context; // rax
unsigned int v4; // ecx
unsigned long long v5; // rdx
v2 = (_QWORD *)*((_QWORD *)a2 + 69);
tx_context = evmone::ExecutionState::get_tx_context(a2);
v4 = *(_DWORD *)(tx_context + 32);
v5 = *(_QWORD *)(tx_context + 36);
v2[4] = _byteswap_uint64(*(_QWORD *)(tx_context + 44));
v2[5] = _byteswap_uint64(v5);
v2[6] = _byteswap_ulong(v4);
v2[7] = 0LL;
*((_QWORD *)a2 + 69) += 32LL;
return a1 + 16;
}
| op<&(void_evmone::advanced::instr::impl<(evmone::Opcode)50,&evmone::instr::core::origin>(evmone::advanced::AdvancedExecutionState&))>:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV R15,qword ptr [RSI + 0x228]
MOV RDI,RSI
CALL 0x001432cc
MOV ECX,dword ptr [RAX + 0x20]
MOV RDX,qword ptr [RAX + 0x24]
MOV RAX,qword ptr [RAX + 0x2c]
BSWAP RAX
BSWAP RDX
BSWAP ECX
MOV qword ptr [R15 + 0x20],RAX
MOV qword ptr [R15 + 0x28],RDX
MOV qword ptr [R15 + 0x30],RCX
MOV qword ptr [R15 + 0x38],0x0
ADD qword ptr [RBX + 0x228],0x20
ADD R14,0x10
MOV RAX,R14
POP RBX
POP R14
POP R15
RET
|
/* evmone::advanced::Instruction const* evmone::advanced::(anonymous namespace)::op<&(void
evmone::advanced::instr::impl<(evmone::Opcode)50,
&evmone::instr::core::origin>(evmone::advanced::AdvancedExecutionState&))>(evmone::advanced::Instruction
const*, evmone::advanced::AdvancedExecutionState&) */
Instruction *
evmone::advanced::(anonymous_namespace)::
op<&(void_evmone::advanced::instr::impl<(evmone::Opcode)50,&evmone::instr::core::origin>(evmone::advanced::AdvancedExecutionState&))>
(Instruction *param_1,AdvancedExecutionState *param_2)
{
uint uVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
lVar2 = *(long *)(param_2 + 0x228);
lVar5 = ExecutionState::get_tx_context((ExecutionState *)param_2);
uVar1 = *(uint *)(lVar5 + 0x20);
uVar3 = *(ulong *)(lVar5 + 0x24);
uVar4 = *(ulong *)(lVar5 + 0x2c);
*(ulong *)(lVar2 + 0x20) =
uVar4 >> 0x38 | (uVar4 & 0xff000000000000) >> 0x28 | (uVar4 & 0xff0000000000) >> 0x18 |
(uVar4 & 0xff00000000) >> 8 | (uVar4 & 0xff000000) << 8 | (uVar4 & 0xff0000) << 0x18 |
(uVar4 & 0xff00) << 0x28 | uVar4 << 0x38;
*(ulong *)(lVar2 + 0x28) =
uVar3 >> 0x38 | (uVar3 & 0xff000000000000) >> 0x28 | (uVar3 & 0xff0000000000) >> 0x18 |
(uVar3 & 0xff00000000) >> 8 | (uVar3 & 0xff000000) << 8 | (uVar3 & 0xff0000) << 0x18 |
(uVar3 & 0xff00) << 0x28 | uVar3 << 0x38;
*(ulong *)(lVar2 + 0x30) =
(ulong)(uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18);
*(int8 *)(lVar2 + 0x38) = 0;
*(long *)(param_2 + 0x228) = *(long *)(param_2 + 0x228) + 0x20;
return param_1 + 0x10;
}
| |
51,215 | ma_net_write_command | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_write_command(NET *net, uchar command,
const char *packet, size_t len,
my_bool disable_flush)
{
uchar buff[NET_HEADER_SIZE+1];
size_t buff_size= NET_HEADER_SIZE + 1;
size_t length= 1 + len; /* 1 extra byte for command */
int rc;
buff[NET_HEADER_SIZE]= 0;
buff[4]=command;
if (length >= MAX_PACKET_LENGTH)
{
len= MAX_PACKET_LENGTH - 1;
do
{
int3store(buff, MAX_PACKET_LENGTH);
buff[3]= (net->compress) ? 0 : (uchar) (net->pkt_nr++);
if (ma_net_write_buff(net, (char *)buff, buff_size) ||
ma_net_write_buff(net, packet, len))
return(1);
packet+= len;
length-= MAX_PACKET_LENGTH;
len= MAX_PACKET_LENGTH;
buff_size= NET_HEADER_SIZE; /* don't send command for further packets */
} while (length >= MAX_PACKET_LENGTH);
len= length;
}
int3store(buff,length);
buff[3]= (net->compress) ? 0 :(uchar) (net->pkt_nr++);
rc= test (ma_net_write_buff(net,(char *)buff, buff_size) ||
ma_net_write_buff(net,packet,len));
if (!rc && !disable_flush)
return test(ma_net_flush(net));
return rc;
} | O3 | c | ma_net_write_command:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, -0x3c(%rbp)
movq %rdx, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq 0x1(%rcx), %rax
movb %sil, -0x31(%rbp)
movl $0x5, %edx
cmpq $0xffffff, %rax # imm = 0xFFFFFF
jb 0x3440e
movl $0xfffffe, %r14d # imm = 0xFFFFFE
movq %rax, %r12
movb $0x1, %r13b
movw $0xffff, -0x35(%rbp) # imm = 0xFFFF
movb $-0x1, -0x33(%rbp)
cmpb $0x0, 0x84(%rbx)
je 0x343b5
xorl %eax, %eax
jmp 0x343be
movl 0x60(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%rbx)
movb %al, -0x32(%rbp)
movq %rbx, %rdi
leaq -0x35(%rbp), %rsi
callq 0x34239
testl %eax, %eax
jne 0x34475
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x34239
testl %eax, %eax
jne 0x34475
addq %r14, %r15
addq $-0xffffff, %r12 # imm = 0xFF000001
movl $0x4, %edx
movl $0xffffff, %r14d # imm = 0xFFFFFF
movq %r12, %rax
cmpq $0xfffffe, %r12 # imm = 0xFFFFFE
ja 0x3439e
jmp 0x34411
movq %rcx, %r12
movb %al, -0x35(%rbp)
movb %ah, -0x34(%rbp)
shrl $0x10, %eax
movb %al, -0x33(%rbp)
cmpb $0x0, 0x84(%rbx)
je 0x3442a
xorl %eax, %eax
jmp 0x34433
movl 0x60(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%rbx)
leaq -0x35(%rbp), %rsi
movb %al, 0x3(%rsi)
movq %rbx, %rdi
callq 0x34239
movb $0x1, %r13b
testl %eax, %eax
jne 0x34475
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x34239
testl %eax, %eax
setne %r13b
cmpb $0x0, -0x3c(%rbp)
jne 0x34475
testl %eax, %eax
jne 0x34475
movq %rbx, %rdi
callq 0x33ef6
testl %eax, %eax
setne %r13b
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x34497
movzbl %r13b, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| ma_net_write_command:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_3C], r8d
mov r15, rdx
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea rax, [rcx+1]
mov [rbp+var_31], sil
mov edx, 5
cmp rax, 0FFFFFFh
jb short loc_3440E
mov r14d, 0FFFFFEh
mov r12, rax
mov r13b, 1
loc_3439E:
mov [rbp+var_35], 0FFFFh
mov [rbp+var_33], 0FFh
cmp byte ptr [rbx+84h], 0
jz short loc_343B5
xor eax, eax
jmp short loc_343BE
loc_343B5:
mov eax, [rbx+60h]
lea ecx, [rax+1]
mov [rbx+60h], ecx
loc_343BE:
mov [rbp+var_32], al
mov rdi, rbx
lea rsi, [rbp+var_35]
call ma_net_write_buff
test eax, eax
jnz loc_34475
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call ma_net_write_buff
test eax, eax
jnz loc_34475
add r15, r14
add r12, 0FFFFFFFFFF000001h
mov edx, 4
mov r14d, 0FFFFFFh
mov rax, r12
cmp r12, 0FFFFFEh
ja short loc_3439E
jmp short loc_34411
loc_3440E:
mov r12, rcx
loc_34411:
mov byte ptr [rbp+var_35], al
mov byte ptr [rbp+var_35+1], ah
shr eax, 10h
mov [rbp+var_33], al
cmp byte ptr [rbx+84h], 0
jz short loc_3442A
xor eax, eax
jmp short loc_34433
loc_3442A:
mov eax, [rbx+60h]
lea ecx, [rax+1]
mov [rbx+60h], ecx
loc_34433:
lea rsi, [rbp+var_35]
mov [rsi+3], al
mov rdi, rbx
call ma_net_write_buff
mov r13b, 1
test eax, eax
jnz short loc_34475
mov rdi, rbx
mov rsi, r15
mov rdx, r12
call ma_net_write_buff
test eax, eax
setnz r13b
cmp byte ptr [rbp+var_3C], 0
jnz short loc_34475
test eax, eax
jnz short loc_34475
mov rdi, rbx
call ma_net_flush
test eax, eax
setnz r13b
loc_34475:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_34497
movzx eax, r13b
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_34497:
call ___stack_chk_fail
| _BOOL8 ma_net_write_command(long long a1, char a2, long long a3, unsigned long long a4, char a5)
{
int v6; // eax
unsigned long long v7; // rdx
unsigned long long v8; // r14
unsigned long long v9; // r12
bool v10; // r13
int v11; // eax
int v12; // eax
BOOL v13; // eax
__int16 v16; // [rsp+Bh] [rbp-35h] BYREF
char v17; // [rsp+Dh] [rbp-33h]
char v18; // [rsp+Eh] [rbp-32h]
char v19; // [rsp+Fh] [rbp-31h]
unsigned long long v20; // [rsp+10h] [rbp-30h]
v20 = __readfsqword(0x28u);
v6 = a4 + 1;
v19 = a2;
v7 = 5LL;
if ( a4 + 1 < 0xFFFFFF )
{
v9 = a4;
LABEL_11:
v16 = v6;
v17 = BYTE2(v6);
if ( *(_BYTE *)(a1 + 132) )
{
LOBYTE(v12) = 0;
}
else
{
v12 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v12 + 1;
}
v18 = v12;
v10 = 1;
if ( !ma_net_write_buff(a1, (long long)&v16, v7) )
{
v13 = ma_net_write_buff(a1, a3, v9);
v10 = v13;
if ( !a5 && !v13 )
return (unsigned int)ma_net_flush(a1) != 0;
}
}
else
{
v8 = 16777214LL;
v9 = a4 + 1;
v10 = 1;
while ( 1 )
{
v16 = -1;
v17 = -1;
if ( *(_BYTE *)(a1 + 132) )
{
LOBYTE(v11) = 0;
}
else
{
v11 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v11 + 1;
}
v18 = v11;
if ( ma_net_write_buff(a1, (long long)&v16, v7) || ma_net_write_buff(a1, a3, v8) )
break;
a3 += v8;
v9 -= 0xFFFFFFLL;
v7 = 4LL;
v8 = 0xFFFFFFLL;
v6 = v9;
if ( v9 <= 0xFFFFFE )
goto LABEL_11;
}
}
return v10;
}
| ma_net_write_command:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x3c],R8D
MOV R15,RDX
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RCX + 0x1]
MOV byte ptr [RBP + -0x31],SIL
MOV EDX,0x5
CMP RAX,0xffffff
JC 0x0013440e
MOV R14D,0xfffffe
MOV R12,RAX
MOV R13B,0x1
LAB_0013439e:
MOV word ptr [RBP + -0x35],0xffff
MOV byte ptr [RBP + -0x33],0xff
CMP byte ptr [RBX + 0x84],0x0
JZ 0x001343b5
XOR EAX,EAX
JMP 0x001343be
LAB_001343b5:
MOV EAX,dword ptr [RBX + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RBX + 0x60],ECX
LAB_001343be:
MOV byte ptr [RBP + -0x32],AL
MOV RDI,RBX
LEA RSI,[RBP + -0x35]
CALL 0x00134239
TEST EAX,EAX
JNZ 0x00134475
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00134239
TEST EAX,EAX
JNZ 0x00134475
ADD R15,R14
ADD R12,-0xffffff
MOV EDX,0x4
MOV R14D,0xffffff
MOV RAX,R12
CMP R12,0xfffffe
JA 0x0013439e
JMP 0x00134411
LAB_0013440e:
MOV R12,RCX
LAB_00134411:
MOV byte ptr [RBP + -0x35],AL
MOV byte ptr [RBP + -0x34],AH
SHR EAX,0x10
MOV byte ptr [RBP + -0x33],AL
CMP byte ptr [RBX + 0x84],0x0
JZ 0x0013442a
XOR EAX,EAX
JMP 0x00134433
LAB_0013442a:
MOV EAX,dword ptr [RBX + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RBX + 0x60],ECX
LAB_00134433:
LEA RSI,[RBP + -0x35]
MOV byte ptr [RSI + 0x3],AL
MOV RDI,RBX
CALL 0x00134239
MOV R13B,0x1
TEST EAX,EAX
JNZ 0x00134475
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
CALL 0x00134239
TEST EAX,EAX
SETNZ R13B
CMP byte ptr [RBP + -0x3c],0x0
JNZ 0x00134475
TEST EAX,EAX
JNZ 0x00134475
MOV RDI,RBX
CALL 0x00133ef6
TEST EAX,EAX
SETNZ R13B
LAB_00134475:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00134497
MOVZX EAX,R13B
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00134497:
CALL 0x00113500
|
bool ma_net_write_command(long param_1,int1 param_2,long param_3,ulong param_4,char param_5)
{
int iVar1;
int8 uVar2;
ulong uVar3;
long lVar4;
long in_FS_OFFSET;
bool bVar5;
int2 local_3d;
int1 local_3b;
int1 local_3a;
int1 local_39;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = param_4 + 1;
uVar2 = 5;
local_39 = param_2;
if (0xfffffe < uVar3) {
lVar4 = 0xfffffe;
bVar5 = true;
do {
local_3d = 0xffff;
local_3b = 0xff;
if (*(char *)(param_1 + 0x84) == '\0') {
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
}
else {
iVar1 = 0;
}
local_3a = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3d,uVar2);
if ((iVar1 != 0) || (iVar1 = ma_net_write_buff(param_1,param_3,lVar4), iVar1 != 0))
goto LAB_00134475;
param_3 = param_3 + lVar4;
uVar3 = uVar3 - 0xffffff;
uVar2 = 4;
lVar4 = 0xffffff;
param_4 = uVar3;
} while (0xfffffe < uVar3);
}
local_3d = (int2)uVar3;
local_3b = (int1)(uVar3 >> 0x10);
if (*(char *)(param_1 + 0x84) == '\0') {
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
}
else {
iVar1 = 0;
}
local_3a = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3d,uVar2);
bVar5 = true;
if (iVar1 == 0) {
iVar1 = ma_net_write_buff(param_1,param_3,param_4);
bVar5 = iVar1 != 0;
if ((param_5 == '\0') && (iVar1 == 0)) {
iVar1 = ma_net_flush(param_1);
bVar5 = iVar1 != 0;
}
}
LAB_00134475:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return bVar5;
}
| |
51,216 | mysql_close_cont | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_close_cont(MYSQL *sock, int ready_status)
{
int res;
res= mysql_close_slow_part_cont(sock, ready_status);
if (res)
return res;
mysql_close(sock);
return 0;
} | O3 | c | mysql_close_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2a35f
movl %eax, %r14d
testl %eax, %eax
jne 0x2a495
movq %rbx, %rdi
callq 0x1a630
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
| mysql_close_cont:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
call mysql_close_slow_part_cont
mov r14d, eax
test eax, eax
jnz short loc_2A495
mov rdi, rbx
call mysql_close
loc_2A495:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
| long long mysql_close_cont(long long a1, unsigned int a2)
{
unsigned int v2; // r14d
v2 = mysql_close_slow_part_cont(a1, a2);
if ( !v2 )
mysql_close(a1);
return v2;
}
| mysql_close_cont:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CALL 0x0012a35f
MOV R14D,EAX
TEST EAX,EAX
JNZ 0x0012a495
MOV RDI,RBX
CALL 0x0011a630
LAB_0012a495:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
|
int mysql_close_cont(int8 param_1)
{
int iVar1;
iVar1 = mysql_close_slow_part_cont();
if (iVar1 == 0) {
mysql_close(param_1);
}
return iVar1;
}
| |
51,217 | my_like_range_win1250ch | eloqsql/strings/ctype-win1250ch.c | static my_bool
my_like_range_win1250ch(CHARSET_INFO *cs __attribute__((unused)),
const char *ptr, size_t ptr_length,
pbool escape, pbool w_one, pbool w_many,
size_t res_length,
char *min_str, char *max_str,
size_t *min_length, size_t *max_length)
{
int only_min_found= 1;
const char *end = ptr + ptr_length;
char *min_org = min_str;
char *min_end = min_str + res_length;
/* return 1; */
for (; ptr != end && min_str != min_end ; ptr++)
{
if (*ptr == escape && ptr+1 != end)
ptr++; /* Skip escape */
else if (*ptr == w_one || *ptr == w_many) /* '_' or '%' in SQL */
break;
*min_str= like_range_prefix_min_win1250ch[(uint) (uchar) (*ptr)];
if (*min_str != min_sort_char)
only_min_found= 0;
min_str++;
*max_str++= like_range_prefix_max_win1250ch[(uint) (uchar) (*ptr)];
}
if (cs->state & MY_CS_BINSORT)
*min_length= (size_t) (min_str - min_org);
else
{
/* 'a\0\0... is the smallest possible string */
*min_length= res_length;
}
/* a\ff\ff... is the biggest possible string */
*max_length= res_length;
while (min_str != min_end)
{
*min_str++ = min_sort_char;
*max_str++ = max_sort_char;
}
return (only_min_found);
} | O0 | c | my_like_range_win1250ch:
pushq %rbp
movq %rsp, %rbp
movl %r8d, -0x50(%rbp)
movl %ecx, %eax
movl -0x50(%rbp), %ecx
movl %eax, -0x4c(%rbp)
movq %rdx, %rax
movl -0x4c(%rbp), %edx
movq %rax, -0x48(%rbp)
movq %rsi, %rax
movq -0x48(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq %rdi, %r8
movq -0x40(%rbp), %rdi
movb %r9b, %al
movq 0x30(%rbp), %r9
movq 0x28(%rbp), %r9
movq 0x20(%rbp), %r9
movq 0x18(%rbp), %r9
movq 0x10(%rbp), %r9
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %dl, -0x19(%rbp)
movb %cl, -0x1a(%rbp)
movb %al, -0x1b(%rbp)
movl $0x1, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rbp), %rax
addq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x51(%rbp)
je 0xbd1cc
movq 0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xbd1d8
jmp 0xbd296
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0xbd203
movq -0x10(%rbp), %rax
addq $0x1, %rax
cmpq -0x28(%rbp), %rax
je 0xbd203
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xbd225
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
je 0xbd221
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x1b(%rbp), %ecx
cmpl %ecx, %eax
jne 0xbd223
jmp 0xbd296
jmp 0xbd225
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x14efc9(%rip), %rax # 0x20c200
movb (%rax,%rcx), %cl
movq 0x18(%rbp), %rax
movb %cl, (%rax)
movq 0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0xbd253
movl $0x0, -0x20(%rbp)
movq 0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x32f23f(%rip), %rax # 0x3ec4b0
movb (%rax,%rcx), %cl
movq 0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xbd1af
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xbd2b9
movq 0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rax, %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbd2c4
movq 0x10(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rcx
movq 0x30(%rbp), %rax
movq %rcx, (%rax)
movq 0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0xbd2ff
movq 0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rbp)
movb $0x20, (%rax)
movq 0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rbp)
movb $-0x1, (%rax)
jmp 0xbd2cf
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| my_like_range_win1250ch:
push rbp
mov rbp, rsp
mov [rbp+var_50], r8d
mov eax, ecx
mov ecx, [rbp+var_50]
mov [rbp+var_4C], eax
mov rax, rdx
mov edx, [rbp+var_4C]
mov [rbp+var_48], rax
mov rax, rsi
mov rsi, [rbp+var_48]
mov [rbp+var_40], rax
mov r8, rdi
mov rdi, [rbp+var_40]
mov al, r9b
mov r9, [rbp+arg_20]
mov r9, [rbp+arg_18]
mov r9, [rbp+arg_10]
mov r9, [rbp+arg_8]
mov r9, [rbp+arg_0]
mov [rbp+var_8], r8
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_19], dl
mov [rbp+var_1A], cl
mov [rbp+var_1B], al
mov [rbp+var_20], 1
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_28], rax
mov rax, [rbp+arg_8]
mov [rbp+var_30], rax
mov rax, [rbp+arg_8]
add rax, [rbp+arg_0]
mov [rbp+var_38], rax
loc_BD1AF:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_28]
mov [rbp+var_51], al
jz short loc_BD1CC
mov rax, [rbp+arg_8]
cmp rax, [rbp+var_38]
setnz al
mov [rbp+var_51], al
loc_BD1CC:
mov al, [rbp+var_51]
test al, 1
jnz short loc_BD1D8
jmp loc_BD296
loc_BD1D8:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_19]
cmp eax, ecx
jnz short loc_BD203
mov rax, [rbp+var_10]
add rax, 1
cmp rax, [rbp+var_28]
jz short loc_BD203
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_BD225
loc_BD203:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_1A]
cmp eax, ecx
jz short loc_BD221
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_1B]
cmp eax, ecx
jnz short loc_BD223
loc_BD221:
jmp short loc_BD296
loc_BD223:
jmp short $+2
loc_BD225:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
mov eax, eax
mov ecx, eax
lea rax, like_range_prefix_min_win1250ch
mov cl, [rax+rcx]
mov rax, [rbp+arg_8]
mov [rax], cl
mov rax, [rbp+arg_8]
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
jz short loc_BD253
mov [rbp+var_20], 0
loc_BD253:
mov rax, [rbp+arg_8]
add rax, 1
mov [rbp+arg_8], rax
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
mov eax, eax
mov ecx, eax
lea rax, like_range_prefix_max_win1250ch
mov cl, [rax+rcx]
mov rax, [rbp+arg_10]
mov rdx, rax
add rdx, 1
mov [rbp+arg_10], rdx
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp loc_BD1AF
loc_BD296:
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
and eax, 10h
cmp eax, 0
jz short loc_BD2B9
mov rcx, [rbp+arg_8]
mov rax, [rbp+var_30]
sub rcx, rax
mov rax, [rbp+arg_18]
mov [rax], rcx
jmp short loc_BD2C4
loc_BD2B9:
mov rcx, [rbp+arg_0]
mov rax, [rbp+arg_18]
mov [rax], rcx
loc_BD2C4:
mov rcx, [rbp+arg_0]
mov rax, [rbp+arg_20]
mov [rax], rcx
loc_BD2CF:
mov rax, [rbp+arg_8]
cmp rax, [rbp+var_38]
jz short loc_BD2FF
mov rax, [rbp+arg_8]
mov rcx, rax
add rcx, 1
mov [rbp+arg_8], rcx
mov byte ptr [rax], 20h ; ' '
mov rax, [rbp+arg_10]
mov rcx, rax
add rcx, 1
mov [rbp+arg_10], rcx
mov byte ptr [rax], 0FFh
jmp short loc_BD2CF
loc_BD2FF:
mov eax, [rbp+var_20]
pop rbp
retn
| long long my_like_range_win1250ch(
long long a1,
unsigned __int8 *a2,
long long a3,
char a4,
char a5,
char a6,
long long a7,
_BYTE *a8,
_BYTE *a9,
_QWORD *a10,
_QWORD *a11)
{
_BYTE *v11; // rax
_BYTE *v12; // rax
_BYTE *v13; // rax
bool v15; // [rsp+1h] [rbp-51h]
_BYTE *v16; // [rsp+1Ah] [rbp-38h]
_BYTE *v17; // [rsp+22h] [rbp-30h]
char *v18; // [rsp+2Ah] [rbp-28h]
unsigned int v19; // [rsp+32h] [rbp-20h]
unsigned __int8 *v20; // [rsp+42h] [rbp-10h]
v20 = a2;
v19 = 1;
v18 = (char *)&a2[a3];
v17 = a8;
v16 = &a8[a7];
while ( 1 )
{
v15 = 0;
if ( v20 != (unsigned __int8 *)v18 )
v15 = a8 != v16;
if ( !v15 )
break;
if ( (char)*v20 != a4 || v20 + 1 == (unsigned __int8 *)v18 )
{
if ( (char)*v20 == a5 || (char)*v20 == a6 )
break;
}
else
{
++v20;
}
*a8 = like_range_prefix_min_win1250ch[*v20];
if ( *a8 != 32 )
v19 = 0;
++a8;
v11 = a9++;
*v11 = like_range_prefix_max_win1250ch[*v20++];
}
if ( (*(_DWORD *)(a1 + 12) & 0x10) != 0 )
*a10 = a8 - v17;
else
*a10 = a7;
*a11 = a7;
while ( a8 != v16 )
{
v12 = a8++;
*v12 = 32;
v13 = a9++;
*v13 = -1;
}
return v19;
}
| my_like_range_win1250ch:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x50],R8D
MOV EAX,ECX
MOV ECX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,RDX
MOV EDX,dword ptr [RBP + -0x4c]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,RSI
MOV RSI,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x40],RAX
MOV R8,RDI
MOV RDI,qword ptr [RBP + -0x40]
MOV AL,R9B
MOV R9,qword ptr [RBP + 0x30]
MOV R9,qword ptr [RBP + 0x28]
MOV R9,qword ptr [RBP + 0x20]
MOV R9,qword ptr [RBP + 0x18]
MOV R9,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],R8
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV byte ptr [RBP + -0x19],DL
MOV byte ptr [RBP + -0x1a],CL
MOV byte ptr [RBP + -0x1b],AL
MOV dword ptr [RBP + -0x20],0x1
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + 0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + 0x18]
ADD RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x38],RAX
LAB_001bd1af:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x51],AL
JZ 0x001bd1cc
MOV RAX,qword ptr [RBP + 0x18]
CMP RAX,qword ptr [RBP + -0x38]
SETNZ AL
MOV byte ptr [RBP + -0x51],AL
LAB_001bd1cc:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x001bd1d8
JMP 0x001bd296
LAB_001bd1d8:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x19]
CMP EAX,ECX
JNZ 0x001bd203
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x001bd203
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001bd225
LAB_001bd203:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x1a]
CMP EAX,ECX
JZ 0x001bd221
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x1b]
CMP EAX,ECX
JNZ 0x001bd223
LAB_001bd221:
JMP 0x001bd296
LAB_001bd223:
JMP 0x001bd225
LAB_001bd225:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x30c200]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + 0x18]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + 0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
JZ 0x001bd253
MOV dword ptr [RBP + -0x20],0x0
LAB_001bd253:
MOV RAX,qword ptr [RBP + 0x18]
ADD RAX,0x1
MOV qword ptr [RBP + 0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x4ec4b0]
MOV CL,byte ptr [RAX + RCX*0x1]
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 + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001bd1af
LAB_001bd296:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x10
CMP EAX,0x0
JZ 0x001bd2b9
MOV RCX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x30]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + 0x28]
MOV qword ptr [RAX],RCX
JMP 0x001bd2c4
LAB_001bd2b9:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + 0x28]
MOV qword ptr [RAX],RCX
LAB_001bd2c4:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + 0x30]
MOV qword ptr [RAX],RCX
LAB_001bd2cf:
MOV RAX,qword ptr [RBP + 0x18]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x001bd2ff
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + 0x18],RCX
MOV byte ptr [RAX],0x20
MOV RAX,qword ptr [RBP + 0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + 0x20],RCX
MOV byte ptr [RAX],0xff
JMP 0x001bd2cf
LAB_001bd2ff:
MOV EAX,dword ptr [RBP + -0x20]
POP RBP
RET
|
int4
my_like_range_win1250ch
(long param_1,byte *param_2,long param_3,byte param_4,byte param_5,byte param_6,
long param_7,char *param_8,int1 *param_9,long *param_10,long *param_11)
{
char *pcVar1;
char *pcVar2;
int4 local_28;
byte *local_18;
pcVar1 = param_8;
local_28 = 1;
pcVar2 = param_8 + param_7;
for (local_18 = param_2; local_18 != param_2 + param_3 && param_8 != pcVar2;
local_18 = local_18 + 1) {
if ((*local_18 == param_4) && (local_18 + 1 != param_2 + param_3)) {
local_18 = local_18 + 1;
}
else if ((*local_18 == param_5) || (*local_18 == param_6)) break;
*param_8 = like_range_prefix_min_win1250ch[*local_18];
if (*param_8 != ' ') {
local_28 = 0;
}
param_8 = param_8 + 1;
*param_9 = like_range_prefix_max_win1250ch[*local_18];
param_9 = param_9 + 1;
}
if ((*(uint *)(param_1 + 0xc) & 0x10) == 0) {
*param_10 = param_7;
}
else {
*param_10 = (long)param_8 - (long)pcVar1;
}
*param_11 = param_7;
while (param_8 != pcVar2) {
*param_8 = ' ';
*param_9 = 0xff;
param_8 = param_8 + 1;
param_9 = param_9 + 1;
}
return local_28;
}
| |
51,218 | minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&) | llama.cpp/common/minja/minja.hpp | Context(Value && values, const std::shared_ptr<Context> & parent = nullptr) : values_(std::move(values)), parent_(parent) {
if (!values_.is_object()) throw std::runtime_error("Context values must be an object: " + values_.dump());
} | O3 | cpp | minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0xa16c1(%rip), %rax # 0x161520
addq $0x10, %rax
movq %rax, (%rdi)
movups %xmm0, 0x18(%rdi)
xorl %r13d, %r13d
movq %r13, 0x30(%rdi)
movups 0x10(%rsi), %xmm0
movq %r13, 0x18(%rsi)
movups %xmm0, 0x28(%rdi)
movq %r13, 0x10(%rsi)
movq %r13, 0x40(%rdi)
movups 0x20(%rsi), %xmm0
movq %r13, 0x28(%rsi)
movups %xmm0, 0x38(%rdi)
movq %r13, 0x20(%rsi)
movq %r13, 0x50(%rdi)
movups 0x30(%rsi), %xmm0
movq %r13, 0x38(%rsi)
movups %xmm0, 0x48(%rdi)
movq %r13, 0x30(%rsi)
leaq 0x58(%rdi), %r12
leaq 0x40(%rsi), %rdi
movups 0x40(%rsi), %xmm0
movups %xmm0, 0x58(%rbx)
xorl %esi, %esi
callq 0x8538a
movb $0x0, 0x40(%r15)
movq %r13, 0x48(%r15)
movq %r12, %rdi
movl $0x1, %esi
callq 0x8538a
movq (%r14), %rax
movq %rax, 0x68(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0xbfeff
movq 0xa30a7(%rip), %rcx # 0x162f98
cmpb $0x0, (%rcx)
je 0xbfefb
incl 0x8(%rax)
jmp 0xbfeff
lock
incl 0x8(%rax)
cmpq $0x0, 0x38(%rbx)
je 0xbff15
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rbx), %r14
movl $0x10, %edi
callq 0x20650
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xb6330
leaq 0x600fa(%rip), %rsi # 0x12003b
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xafbd0
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x20480
xorl %ebp, %ebp
movq 0xa3057(%rip), %rsi # 0x162fc0
movq 0xa3010(%rip), %rdx # 0x162f80
movq %r15, %rdi
callq 0x20a50
movq %rax, %r12
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbff96
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x20180
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbffb1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
testb %bpl, %bpl
jne 0xbffdb
jmp 0xbffe3
movq %rax, %r12
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbffdb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
jmp 0xbffdb
movq %rax, %r12
movq %r15, %rdi
callq 0x20f00
leaq 0x8(%rbx), %r15
addq $0x70, %rbx
movq %rbx, %rdi
callq 0x70a60
movq %r14, %rdi
callq 0xb63cc
movq %r15, %rdi
callq 0xc000c
movq %r12, %rdi
callq 0x20af0
nop
| _ZN5minja7ContextC2EONS_5ValueERKSt10shared_ptrIS0_E:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
lea rax, _ZTVN5minja7ContextE; `vtable for'minja::Context
add rax, 10h
mov [rdi], rax
movups xmmword ptr [rdi+18h], xmm0
xor r13d, r13d
mov [rdi+30h], r13
movups xmm0, xmmword ptr [rsi+10h]
mov [rsi+18h], r13
movups xmmword ptr [rdi+28h], xmm0
mov [rsi+10h], r13
mov [rdi+40h], r13
movups xmm0, xmmword ptr [rsi+20h]
mov [rsi+28h], r13
movups xmmword ptr [rdi+38h], xmm0
mov [rsi+20h], r13
mov [rdi+50h], r13
movups xmm0, xmmword ptr [rsi+30h]
mov [rsi+38h], r13
movups xmmword ptr [rdi+48h], xmm0
mov [rsi+30h], r13
lea r12, [rdi+58h]
lea rdi, [rsi+40h]
movups xmm0, xmmword ptr [rsi+40h]
movups xmmword ptr [rbx+58h], xmm0
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r15+40h], 0
mov [r15+48h], r13
mov rdi, r12
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 rax, [r14]
mov [rbx+68h], rax
mov rax, [r14+8]
mov [rbx+70h], rax
test rax, rax
jz short loc_BFEFF
mov rcx, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rcx], 0
jz short loc_BFEFB
inc dword ptr [rax+8]
jmp short loc_BFEFF
loc_BFEFB:
lock inc dword ptr [rax+8]
loc_BFEFF:
cmp qword ptr [rbx+38h], 0
jz short loc_BFF15
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_BFF15:
lea r14, [rbx+18h]
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rdi, [rsp+78h+var_70]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aContextValuesM; "Context values must be an object: "
lea rdi, [rsp+78h+var_50]
lea rdx, [rsp+78h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_50]
mov rdi, r15
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
mov r12, rax
lea rax, [rsp+78h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BFF96
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BFF96:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BFFB1
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BFFB1:
test bpl, bpl
jnz short loc_BFFDB
jmp short loc_BFFE3
mov r12, rax
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BFFDB
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BFFDB
mov r12, rax
loc_BFFDB:
mov rdi, r15; void *
call ___cxa_free_exception
loc_BFFE3:
lea r15, [rbx+8]
add rbx, 70h ; 'p'
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, r15
call _ZNSt23enable_shared_from_thisIN5minja7ContextEED2Ev; std::enable_shared_from_this<minja::Context>::~enable_shared_from_this()
mov rdi, r12
call __Unwind_Resume
| long long minja::Context::Context(long long a1, long long a2, _QWORD *a3)
{
__int128 v4; // xmm0
__int128 v5; // xmm0
__int128 v6; // xmm0
long long result; // rax
void *exception; // r15
_BYTE v9[16]; // [rsp+8h] [rbp-70h] BYREF
_QWORD v10[2]; // [rsp+28h] [rbp-50h] BYREF
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)a1 = &`vtable for'minja::Context + 2;
*(_OWORD *)(a1 + 24) = 0LL;
*(_QWORD *)(a1 + 48) = 0LL;
v4 = *(_OWORD *)(a2 + 16);
*(_QWORD *)(a2 + 24) = 0LL;
*(_OWORD *)(a1 + 40) = v4;
*(_QWORD *)(a2 + 16) = 0LL;
*(_QWORD *)(a1 + 64) = 0LL;
v5 = *(_OWORD *)(a2 + 32);
*(_QWORD *)(a2 + 40) = 0LL;
*(_OWORD *)(a1 + 56) = v5;
*(_QWORD *)(a2 + 32) = 0LL;
*(_QWORD *)(a1 + 80) = 0LL;
v6 = *(_OWORD *)(a2 + 48);
*(_QWORD *)(a2 + 56) = 0LL;
*(_OWORD *)(a1 + 72) = v6;
*(_QWORD *)(a2 + 48) = 0LL;
*(_OWORD *)(a1 + 88) = *(_OWORD *)(a2 + 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 *)(a2 + 64));
*(_BYTE *)(a2 + 64) = 0;
*(_QWORD *)(a2 + 72) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 88));
*(_QWORD *)(a1 + 104) = *a3;
result = a3[1];
*(_QWORD *)(a1 + 112) = result;
if ( result )
{
if ( _libc_single_threaded )
++*(_DWORD *)(result + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(result + 8));
}
if ( !*(_QWORD *)(a1 + 56) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v9, a1 + 24, 0xFFFFFFFF, 0);
std::operator+<char>(v10, (long long)"Context values must be an object: ", (long long)v9);
std::runtime_error::runtime_error(exception, v10);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return result;
}
| Context:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
LEA RAX,[0x261520]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOVUPS xmmword ptr [RDI + 0x18],XMM0
XOR R13D,R13D
MOV qword ptr [RDI + 0x30],R13
MOVUPS XMM0,xmmword ptr [RSI + 0x10]
MOV qword ptr [RSI + 0x18],R13
MOVUPS xmmword ptr [RDI + 0x28],XMM0
MOV qword ptr [RSI + 0x10],R13
MOV qword ptr [RDI + 0x40],R13
MOVUPS XMM0,xmmword ptr [RSI + 0x20]
MOV qword ptr [RSI + 0x28],R13
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOV qword ptr [RSI + 0x20],R13
MOV qword ptr [RDI + 0x50],R13
MOVUPS XMM0,xmmword ptr [RSI + 0x30]
MOV qword ptr [RSI + 0x38],R13
MOVUPS xmmword ptr [RDI + 0x48],XMM0
MOV qword ptr [RSI + 0x30],R13
LEA R12,[RDI + 0x58]
LEA RDI,[RSI + 0x40]
MOVUPS XMM0,xmmword ptr [RSI + 0x40]
MOVUPS xmmword ptr [RBX + 0x58],XMM0
XOR ESI,ESI
CALL 0x0018538a
MOV byte ptr [R15 + 0x40],0x0
MOV qword ptr [R15 + 0x48],R13
MOV RDI,R12
MOV ESI,0x1
CALL 0x0018538a
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX + 0x68],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX + 0x70],RAX
TEST RAX,RAX
JZ 0x001bfeff
MOV RCX,qword ptr [0x00262f98]
CMP byte ptr [RCX],0x0
JZ 0x001bfefb
INC dword ptr [RAX + 0x8]
JMP 0x001bfeff
LAB_001bfefb:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001bfeff:
CMP qword ptr [RBX + 0x38],0x0
JZ 0x001bff15
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001bff15:
LEA R14,[RBX + 0x18]
MOV EDI,0x10
CALL 0x00120650
MOV R15,RAX
LAB_001bff26:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001b6330
LAB_001bff3a:
LEA RSI,[0x22003b]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x001afbd0
MOV BPL,0x1
LAB_001bff53:
LEA RSI,[RSP + 0x28]
MOV RDI,R15
CALL 0x00120480
XOR EBP,EBP
MOV RSI,qword ptr [0x00262fc0]
MOV RDX,qword ptr [0x00262f80]
MOV RDI,R15
CALL 0x00120a50
|
/* minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&) */
void __thiscall minja::Context::Context(Context *this,Value *param_1,shared_ptr *param_2)
{
long lVar1;
int8 uVar2;
runtime_error *this_00;
int1 local_70 [32];
string local_50 [32];
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int ***)this = &PTR__Context_00261530;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x30) = 0;
uVar2 = *(int8 *)(param_1 + 0x18);
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(this + 0x28) = *(int8 *)(param_1 + 0x10);
*(int8 *)(this + 0x30) = uVar2;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(this + 0x40) = 0;
uVar2 = *(int8 *)(param_1 + 0x28);
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(this + 0x38) = *(int8 *)(param_1 + 0x20);
*(int8 *)(this + 0x40) = uVar2;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(this + 0x50) = 0;
uVar2 = *(int8 *)(param_1 + 0x38);
*(int8 *)(param_1 + 0x38) = 0;
*(int8 *)(this + 0x48) = *(int8 *)(param_1 + 0x30);
*(int8 *)(this + 0x50) = uVar2;
*(int8 *)(param_1 + 0x30) = 0;
uVar2 = *(int8 *)(param_1 + 0x48);
*(int8 *)(this + 0x58) = *(int8 *)(param_1 + 0x40);
*(int8 *)(this + 0x60) = uVar2;
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((bool)((char)param_1 + '@'));
param_1[0x40] = (Value)0x0;
*(int8 *)(param_1 + 0x48) = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant((bool)((char)this + 'X'));
*(int8 *)(this + 0x68) = *(int8 *)param_2;
lVar1 = *(long *)(param_2 + 8);
*(long *)(this + 0x70) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_00262f98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
if (*(long *)(this + 0x38) != 0) {
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001bff26 to 001bff39 has its CatchHandler @ 001bffd8 */
Value::dump_abi_cxx11_((int)local_70,(bool)((char)this + '\x18'));
/* try { // try from 001bff3a to 001bff4f has its CatchHandler @ 001bffb8 */
std::operator+((char *)local_50,(string *)"Context values must be an object: ");
/* try { // try from 001bff53 to 001bff77 has its CatchHandler @ 001bff78 */
std::runtime_error::runtime_error(this_00,local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00262fc0,PTR__runtime_error_00262f80);
}
| |
51,219 | LefDefParser::lefwLayerRoutingArea(double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwLayerRoutingArea(double area)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_LAYERROUTING_START &&
lefwState != LEFW_LAYERROUTING)
return LEFW_BAD_ORDER;
if (!lefwIsRouting)
return LEFW_BAD_DATA; // only routing calls this func
if (prtSemiColon) {
// the previous statement hasn't written the ; yet
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) ";\n");
else
fprintf(lefwFile, ";\n");
prtSemiColon = 0;
}
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " AREA %.11g ;\n", area);
else
fprintf(lefwFile, " AREA %.11g ;\n", area);
lefwLines++;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwLayerRoutingArea(double):
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
leaq 0x22bbf(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x10254
movl $0x1, 0x14(%rsp)
jmp 0x10344
leaq 0x22df5(%rip), %rax # 0x33050
cmpl $0x7, (%rax)
je 0x10279
leaq 0x22de9(%rip), %rax # 0x33050
cmpl $0x1f, (%rax)
je 0x10279
movl $0x2, 0x14(%rsp)
jmp 0x10344
leaq 0x22e44(%rip), %rax # 0x330c4
cmpl $0x0, (%rax)
jne 0x10292
movl $0x3, 0x14(%rsp)
jmp 0x10344
cmpl $0x0, 0x22e5b(%rip) # 0x330f4
je 0x102e0
cmpl $0x0, 0x22e4a(%rip) # 0x330ec
je 0x102be
leaq 0x22b55(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x19c9f(%rip), %rsi # 0x29f54
movb $0x0, %al
callq 0x289b0
jmp 0x102d6
leaq 0x22b3b(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x19c85(%rip), %rsi # 0x29f54
movb $0x0, %al
callq 0x1100
movl $0x0, 0x22e14(%rip) # 0x330f4
cmpl $0x0, 0x22e05(%rip) # 0x330ec
je 0x10309
leaq 0x22b10(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x1a0fd(%rip), %rsi # 0x2a3fd
movb $0x1, %al
callq 0x289b0
jmp 0x10327
leaq 0x22af0(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x1a0dd(%rip), %rsi # 0x2a3fd
movb $0x1, %al
callq 0x1100
leaq 0x22d1e(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x22d12(%rip), %rax # 0x3304c
movl %ecx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN12LefDefParser20lefwLayerRoutingAreaEd:
sub rsp, 18h
movsd [rsp+18h+var_10], xmm0
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_10254
mov [rsp+18h+var_4], 1
jmp loc_10344
loc_10254:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 7
jz short loc_10279
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 1Fh
jz short loc_10279
mov [rsp+18h+var_4], 2
jmp loc_10344
loc_10279:
lea rax, _ZN12LefDefParser13lefwIsRoutingE; LefDefParser::lefwIsRouting
cmp dword ptr [rax], 0
jnz short loc_10292
mov [rsp+18h+var_4], 3
jmp loc_10344
loc_10292:
cmp cs:_ZN12LefDefParserL12prtSemiColonE, 0; LefDefParser::prtSemiColon
jz short loc_102E0
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_102BE
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 short loc_102D6
loc_102BE:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aDividercharS+11h; ";\n"
mov al, 0
call _fprintf
loc_102D6:
mov cs:_ZN12LefDefParserL12prtSemiColonE, 0; LefDefParser::prtSemiColon
loc_102E0:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_10309
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
lea rsi, aArea11g_0; " AREA %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_10327
loc_10309:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
lea rsi, aArea11g_0; " AREA %.11g ;\n"
mov al, 1
call _fprintf
loc_10327:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
mov [rsp+18h+var_4], 0
loc_10344:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long LefDefParser::lefwLayerRoutingArea(
LefDefParser *this,
double a2,
long long a3,
int a4,
int a5,
int a6,
int a7)
{
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwState == 7 || LefDefParser::lefwState == 31 )
{
if ( LefDefParser::lefwIsRouting )
{
if ( LefDefParser::prtSemiColon )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)";\n", a4, a5, a6, a7);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, ";\n");
LefDefParser::prtSemiColon = 0;
}
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" AREA %.11g ;\n", a4, a5, a6, a7);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " AREA %.11g ;\n", a2);
++LefDefParser::lefwLines;
return 0;
}
else
{
return 3;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwLayerRoutingArea:
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x8],XMM0
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x00110254
MOV dword ptr [RSP + 0x14],0x1
JMP 0x00110344
LAB_00110254:
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x7
JZ 0x00110279
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x1f
JZ 0x00110279
MOV dword ptr [RSP + 0x14],0x2
JMP 0x00110344
LAB_00110279:
LEA RAX,[0x1330c4]
CMP dword ptr [RAX],0x0
JNZ 0x00110292
MOV dword ptr [RSP + 0x14],0x3
JMP 0x00110344
LAB_00110292:
CMP dword ptr [0x001330f4],0x0
JZ 0x001102e0
CMP dword ptr [0x001330ec],0x0
JZ 0x001102be
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x129f54]
MOV AL,0x0
CALL 0x001289b0
JMP 0x001102d6
LAB_001102be:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x129f54]
MOV AL,0x0
CALL 0x00101100
LAB_001102d6:
MOV dword ptr [0x001330f4],0x0
LAB_001102e0:
CMP dword ptr [0x001330ec],0x0
JZ 0x00110309
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x12a3fd]
MOV AL,0x1
CALL 0x001289b0
JMP 0x00110327
LAB_00110309:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x12a3fd]
MOV AL,0x1
CALL 0x00101100
LAB_00110327:
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x14],0x0
LAB_00110344:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwLayerRoutingArea(double) */
int4 LefDefParser::lefwLayerRoutingArea(double param_1)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if ((lefwState == 7) || (lefwState == 0x1f)) {
if (lefwIsRouting == 0) {
local_4 = 3;
}
else {
if (prtSemiColon != 0) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile,";\n");
}
else {
encPrint(lefwFile,";\n");
}
prtSemiColon = 0;
}
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," AREA %.11g ;\n",param_1);
}
else {
encPrint(lefwFile," AREA %.11g ;\n",param_1);
}
lefwLines = lefwLines + 1;
local_4 = 0;
}
}
else {
local_4 = 2;
}
return local_4;
}
| |
51,220 | LefDefParser::lefwLayerRoutingArea(double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwLayerRoutingArea(double area)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_LAYERROUTING_START &&
lefwState != LEFW_LAYERROUTING)
return LEFW_BAD_ORDER;
if (!lefwIsRouting)
return LEFW_BAD_DATA; // only routing calls this func
if (prtSemiColon) {
// the previous statement hasn't written the ; yet
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) ";\n");
else
fprintf(lefwFile, ";\n");
prtSemiColon = 0;
}
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " AREA %.11g ;\n", area);
else
fprintf(lefwFile, " AREA %.11g ;\n", area);
lefwLines++;
return LEFW_OK;
} | O3 | cpp | LefDefParser::lefwLayerRoutingArea(double):
pushq %rbx
subq $0x10, %rsp
leaq 0x1ba8a(%rip), %rbx # 0x24e00
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x93d1
leaq 0x1bccb(%rip), %rax # 0x25050
movl (%rax), %edx
cmpl $0x1f, %edx
je 0x939a
movl $0x2, %eax
cmpl $0x7, %edx
jne 0x9437
leaq 0x1bd23(%rip), %rax # 0x250c4
cmpl $0x0, (%rax)
je 0x93d8
cmpb $0x1, 0x1bd47(%rip) # 0x250f4
jne 0x9402
movsd %xmm0, 0x8(%rsp)
cmpb $0x1, 0x1bd30(%rip) # 0x250ec
jne 0x93df
leaq 0x10e4b(%rip), %rsi # 0x1a210
movq %rcx, %rdi
xorl %eax, %eax
callq 0x18c35
jmp 0x93f5
movl $0x1, %eax
jmp 0x9437
movl $0x3, %eax
jmp 0x9437
leaq 0x10e2a(%rip), %rdi # 0x1a210
movl $0x2, %esi
movl $0x1, %edx
callq 0x1110
movb $0x0, 0x1bcf8(%rip) # 0x250f4
movsd 0x8(%rsp), %xmm0
movq (%rbx), %rdi
cmpb $0x1, 0x1bce0(%rip) # 0x250ec
jne 0x941e
leaq 0x112a4(%rip), %rsi # 0x1a6b9
movb $0x1, %al
callq 0x18c35
jmp 0x942c
leaq 0x11294(%rip), %rsi # 0x1a6b9
movb $0x1, %al
callq 0x10f0
leaq 0x1bc19(%rip), %rax # 0x2504c
incl (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
| _ZN12LefDefParser20lefwLayerRoutingAreaEd:
push rbx
sub rsp, 10h
lea rbx, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rcx, [rbx]
test rcx, rcx
jz short loc_93D1
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov edx, [rax]
cmp edx, 1Fh
jz short loc_939A
mov eax, 2
cmp edx, 7
jnz loc_9437
loc_939A:
lea rax, _ZN12LefDefParser13lefwIsRoutingE; LefDefParser::lefwIsRouting
cmp dword ptr [rax], 0
jz short loc_93D8
cmp cs:_ZN12LefDefParserL12prtSemiColonE, 1; LefDefParser::prtSemiColon
jnz short loc_9402
movsd [rsp+18h+var_10], xmm0
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_93DF
lea rsi, aDividercharS+11h; ";\n"
mov rdi, rcx
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_93F5
loc_93D1:
mov eax, 1
jmp short loc_9437
loc_93D8:
mov eax, 3
jmp short loc_9437
loc_93DF:
lea rdi, aDividercharS+11h; ";\n"
mov esi, 2
mov edx, 1
call _fwrite
loc_93F5:
mov cs:_ZN12LefDefParserL12prtSemiColonE, 0; LefDefParser::prtSemiColon
movsd xmm0, [rsp+18h+var_10]
loc_9402:
mov rdi, [rbx]
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_941E
lea rsi, aArea11g_0; " AREA %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_942C
loc_941E:
lea rsi, aArea11g_0; " AREA %.11g ;\n"
mov al, 1
call _fprintf
loc_942C:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
xor eax, eax
loc_9437:
add rsp, 10h
pop rbx
retn
| long long LefDefParser::lefwLayerRoutingArea(
LefDefParser *this,
double a2,
long long a3,
long long a4,
long long a5,
int a6,
int a7)
{
int v7; // ecx
unsigned int v8; // edx
long long result; // rax
v7 = LefDefParser::lefwFile;
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
v8 = LefDefParser::lefwState;
if ( LefDefParser::lefwState == 31 || (result = 2LL, LefDefParser::lefwState == 7) )
{
if ( LefDefParser::lefwIsRouting )
{
if ( LefDefParser::prtSemiColon == 1 )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)";\n",
LefDefParser::lefwState,
LefDefParser::lefwFile,
a6,
a7);
else
fwrite(";\n", 2LL, 1LL, *(_QWORD *)&LefDefParser::lefwFile);
LefDefParser::prtSemiColon = 0;
}
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" AREA %.11g ;\n", v8, v7, a6, a7);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " AREA %.11g ;\n", a2);
++LefDefParser::lefwLines;
return 0LL;
}
else
{
return 3LL;
}
}
return result;
}
| lefwLayerRoutingArea:
PUSH RBX
SUB RSP,0x10
LEA RBX,[0x124e00]
MOV RCX,qword ptr [RBX]
TEST RCX,RCX
JZ 0x001093d1
LEA RAX,[0x125050]
MOV EDX,dword ptr [RAX]
CMP EDX,0x1f
JZ 0x0010939a
MOV EAX,0x2
CMP EDX,0x7
JNZ 0x00109437
LAB_0010939a:
LEA RAX,[0x1250c4]
CMP dword ptr [RAX],0x0
JZ 0x001093d8
CMP byte ptr [0x001250f4],0x1
JNZ 0x00109402
MOVSD qword ptr [RSP + 0x8],XMM0
CMP byte ptr [0x001250ec],0x1
JNZ 0x001093df
LEA RSI,[0x11a210]
MOV RDI,RCX
XOR EAX,EAX
CALL 0x00118c35
JMP 0x001093f5
LAB_001093d1:
MOV EAX,0x1
JMP 0x00109437
LAB_001093d8:
MOV EAX,0x3
JMP 0x00109437
LAB_001093df:
LEA RDI,[0x11a210]
MOV ESI,0x2
MOV EDX,0x1
CALL 0x00101110
LAB_001093f5:
MOV byte ptr [0x001250f4],0x0
MOVSD XMM0,qword ptr [RSP + 0x8]
LAB_00109402:
MOV RDI,qword ptr [RBX]
CMP byte ptr [0x001250ec],0x1
JNZ 0x0010941e
LEA RSI,[0x11a6b9]
MOV AL,0x1
CALL 0x00118c35
JMP 0x0010942c
LAB_0010941e:
LEA RSI,[0x11a6b9]
MOV AL,0x1
CALL 0x001010f0
LAB_0010942c:
LEA RAX,[0x12504c]
INC dword ptr [RAX]
XOR EAX,EAX
LAB_00109437:
ADD RSP,0x10
POP RBX
RET
|
/* LefDefParser::lefwLayerRoutingArea(double) */
int8 LefDefParser::lefwLayerRoutingArea(double param_1)
{
int8 uVar1;
if (lefwFile == (_IO_FILE *)0x0) {
uVar1 = 1;
}
else if ((lefwState == 0x1f) || (uVar1 = 2, lefwState == 7)) {
if (lefwIsRouting == 0) {
uVar1 = 3;
}
else {
if (prtSemiColon == '\x01') {
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile,";\n");
}
else {
fwrite(";\n",2,1,lefwFile);
}
prtSemiColon = '\0';
}
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile," AREA %.11g ;\n");
}
else {
fprintf(lefwFile," AREA %.11g ;\n",param_1);
}
lefwLines = lefwLines + 1;
uVar1 = 0;
}
}
return uVar1;
}
| |
51,221 | spdlog::details::async_msg::async_msg(std::shared_ptr<spdlog::async_logger>&&, spdlog::details::async_msg_type, spdlog::details::log_msg const&) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/details/thread_pool.h | async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m)
: log_msg_buffer{m},
msg_type{the_type},
worker_ptr{std::move(worker)},
flush_promise{} {} | O0 | c | spdlog::details::async_msg::async_msg(std::shared_ptr<spdlog::async_logger>&&, spdlog::details::async_msg_type, spdlog::details::log_msg const&):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x28(%rsp), %rsi
callq 0x322c0
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, 0x180(%rdi)
addq $0x188, %rdi # imm = 0x188
movq %rdi, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0x823b0
movq 0x10(%rsp), %rdi
addq $0x198, %rdi # imm = 0x198
callq 0x80e30
jmp 0x80df3
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x76af0
movq 0x10(%rsp), %rdi
callq 0x38db0
movq 0x20(%rsp), %rdi
callq 0x14c80
nopw %cs:(%rax,%rax)
nop
| _ZN6spdlog7details9async_msgC2EOSt10shared_ptrINS_12async_loggerEENS0_14async_msg_typeERKNS0_7log_msgE:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov [rsp+48h+var_14], edx
mov [rsp+48h+var_20], rcx
mov rdi, [rsp+48h+var_8]; this
mov [rsp+48h+var_38], rdi; void *
mov rsi, [rsp+48h+var_20]; spdlog::details::log_msg *
call _ZN6spdlog7details14log_msg_bufferC2ERKNS0_7log_msgE; spdlog::details::log_msg_buffer::log_msg_buffer(spdlog::details::log_msg const&)
mov rdi, [rsp+48h+var_38]
mov eax, [rsp+48h+var_14]
mov [rdi+180h], eax
add rdi, 188h
mov qword ptr [rsp+48h+var_40], rdi; int
mov rsi, [rsp+48h+var_10]
call _ZNSt10shared_ptrIN6spdlog12async_loggerEEC2EOS2_; std::shared_ptr<spdlog::async_logger>::shared_ptr(std::shared_ptr<spdlog::async_logger>&&)
mov rdi, [rsp+48h+var_38]
add rdi, 198h; int
call _ZNSt7promiseIvEC2Ev; std::promise<void>::promise(void)
jmp short $+2
loc_80DF3:
add rsp, 48h
retn
mov rdi, [rsp+arg_0]
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
call _ZNSt10shared_ptrIN6spdlog12async_loggerEED2Ev; std::shared_ptr<spdlog::async_logger>::~shared_ptr()
mov rdi, [rsp+arg_8]; this
call _ZN6spdlog7details14log_msg_bufferD2Ev; spdlog::details::log_msg_buffer::~log_msg_buffer()
mov rdi, [rsp+arg_18]
call __Unwind_Resume
| long long spdlog::details::async_msg::async_msg(
spdlog::details::log_msg_buffer *a1,
long long a2,
int a3,
const spdlog::details::log_msg *a4)
{
int v4; // edx
int v5; // ecx
int v6; // r8d
int v7; // r9d
long long v9; // [rsp+0h] [rbp-48h]
int v10; // [rsp+18h] [rbp-30h]
long long v11; // [rsp+20h] [rbp-28h]
spdlog::details::log_msg_buffer::log_msg_buffer(a1, a4);
*((_DWORD *)a1 + 96) = a3;
std::shared_ptr<spdlog::async_logger>::shared_ptr((char *)a1 + 392, a2);
return std::promise<void>::promise((int)a1 + 408, a2, v4, v5, v6, v7, v9, (int)a1 + 392, a1, v10, v11);
}
| async_msg:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV dword ptr [RSP + 0x34],EDX
MOV qword ptr [RSP + 0x28],RCX
MOV RDI,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x10],RDI
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x001322c0
MOV RDI,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RDI + 0x180],EAX
ADD RDI,0x188
MOV qword ptr [RSP + 0x8],RDI
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x001823b0
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x198
LAB_00180dec:
CALL 0x00180e30
LAB_00180df1:
JMP 0x00180df3
LAB_00180df3:
ADD RSP,0x48
RET
|
/* spdlog::details::async_msg::async_msg(std::shared_ptr<spdlog::async_logger>&&,
spdlog::details::async_msg_type, spdlog::details::log_msg const&) */
void __thiscall
spdlog::details::async_msg::async_msg
(async_msg *this,shared_ptr *param_1,int4 param_3,log_msg *param_4)
{
log_msg_buffer::log_msg_buffer((log_msg_buffer *)this,param_4);
*(int4 *)(this + 0x180) = param_3;
std::shared_ptr<spdlog::async_logger>::shared_ptr
((shared_ptr<spdlog::async_logger> *)(this + 0x188),param_1);
/* try { // try from 00180dec to 00180df0 has its CatchHandler @ 00180df8 */
std::promise<void>::promise((promise<void> *)(this + 0x198));
return;
}
| |
51,222 | lre_parse_escape | bluesky950520[P]quickjs/libregexp.c | int lre_parse_escape(const uint8_t **pp, int allow_utf16)
{
const uint8_t *p;
uint32_t c;
p = *pp;
c = *p++;
switch(c) {
case 'b':
c = '\b';
break;
case 'f':
c = '\f';
break;
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'v':
c = '\v';
break;
case 'x':
case 'u':
{
int h, n, i;
uint32_t c1;
if (*p == '{' && allow_utf16) {
p++;
c = 0;
for(;;) {
h = from_hex(*p++);
if (h < 0)
return -1;
c = (c << 4) | h;
if (c > 0x10FFFF)
return -1;
if (*p == '}')
break;
}
p++;
} else {
if (c == 'x') {
n = 2;
} else {
n = 4;
}
c = 0;
for(i = 0; i < n; i++) {
h = from_hex(*p++);
if (h < 0) {
return -1;
}
c = (c << 4) | h;
}
if (is_hi_surrogate(c) &&
allow_utf16 == 2 && p[0] == '\\' && p[1] == 'u') {
/* convert an escaped surrogate pair into a
unicode char */
c1 = 0;
for(i = 0; i < 4; i++) {
h = from_hex(p[2 + i]);
if (h < 0)
break;
c1 = (c1 << 4) | h;
}
if (i == 4 && is_lo_surrogate(c1)) {
p += 6;
c = from_surrogate(c, c1);
}
}
}
}
break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
c -= '0';
if (allow_utf16 == 2) {
/* only accept \0 not followed by digit */
if (c != 0 || lre_is_digit(*p))
return -1;
} else {
/* parse a legacy octal sequence */
uint32_t v;
v = *p - '0';
if (v > 7)
break;
c = (c << 3) | v;
p++;
if (c >= 32)
break;
v = *p - '0';
if (v > 7)
break;
c = (c << 3) | v;
p++;
}
break;
default:
return -2;
}
*pp = p;
return c;
} | O1 | c | lre_parse_escape:
pushq %r14
pushq %rbx
movq (%rdi), %r8
leaq 0x1(%r8), %rcx
movzbl (%r8), %edx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpl $0x61, %edx
jg 0x9458f
addl $-0x30, %edx
cmpl $0x8, %edx
jae 0x947fd
cmpl $0x2, %esi
jne 0x9462e
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %edx, %edx
jne 0x947fd
movzbl (%rcx), %esi
addl $-0x3a, %esi
xorl %edx, %edx
cmpl $-0xa, %esi
jb 0x947f8
jmp 0x947fd
leal -0x6e(%rdx), %r9d
cmpl $0xa, %r9d
ja 0x9466b
leaq 0xebdc(%rip), %r10 # 0xa3180
movslq (%r10,%r9,4), %r9
addq %r10, %r9
jmpq *%r9
testl %esi, %esi
je 0x94687
cmpb $0x7b, (%rcx)
jne 0x94687
addq $0x3, %r8
xorl %edx, %edx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %r8, %rcx
movzbl -0x1(%rcx), %r8d
leal -0x30(%r8), %esi
cmpl $0xa, %esi
jb 0x945fc
leal -0x41(%r8), %esi
cmpl $0x5, %esi
ja 0x945ea
addl $-0x37, %r8d
jmp 0x945f9
leal -0x61(%r8), %esi
addl $-0x57, %r8d
cmpl $0x6, %esi
cmovael %eax, %r8d
movl %r8d, %esi
testl %esi, %esi
js 0x947a5
shll $0x4, %edx
orl %edx, %esi
cmpl $0x10ffff, %esi # imm = 0x10FFFF
ja 0x947aa
leaq 0x1(%rcx), %r8
cmpb $0x7d, (%rcx)
movq %r8, %rcx
movl %esi, %edx
jne 0x945cd
movb $0x1, %r9b
movq %r8, %rcx
jmp 0x947ad
movzbl (%rcx), %eax
addl $-0x30, %eax
cmpl $0x7, %eax
ja 0x947f8
leal (%rax,%rdx,8), %edx
leaq 0x2(%r8), %rcx
cmpl $0x1f, %edx
ja 0x947f8
movzbl (%rcx), %eax
addl $-0x30, %eax
cmpl $0x7, %eax
ja 0x947f8
leal (%rax,%rdx,8), %edx
addq $0x3, %r8
movq %r8, %rcx
jmp 0x947f8
cmpl $0x62, %edx
je 0x9479e
cmpl $0x66, %edx
jne 0x947fd
movl $0xc, %edx
jmp 0x947f8
xorl %eax, %eax
cmpl $0x78, %edx
setne %al
leal 0x2(,%rax,2), %r9d
leaq 0x2(%r8), %rbx
xorl %r10d, %r10d
movl $0xffffffff, %r11d # imm = 0xFFFFFFFF
xorl %edx, %edx
movq %rbx, %rcx
movzbl -0x1(%rbx), %ebx
leal -0x30(%rbx), %eax
cmpl $0xa, %eax
jb 0x946d1
leal -0x41(%rbx), %eax
cmpl $0x5, %eax
ja 0x946c2
addl $-0x37, %ebx
jmp 0x946cf
leal -0x61(%rbx), %eax
addl $-0x57, %ebx
cmpl $0x6, %eax
cmovael %r11d, %ebx
movl %ebx, %eax
testl %eax, %eax
js 0x947a5
shll $0x4, %edx
orl %edx, %eax
decq %r10
leaq 0x1(%rcx), %rbx
movl %eax, %edx
decl %r9d
jne 0x946a6
movb $0x1, %r9b
cmpl $0x2, %esi
jne 0x947ec
movl %eax, %edx
andl $0xfffffc00, %edx # imm = 0xFFFFFC00
cmpl $0xd800, %edx # imm = 0xD800
jne 0x947ec
cmpb $0x5c, -0x1(%rbx)
jne 0x947ec
cmpb $0x75, (%rbx)
jne 0x947ec
subq %r10, %r8
leaq 0x3(%r8), %rsi
xorl %edx, %edx
movl $0xffffffff, %r10d # imm = 0xFFFFFFFF
xorl %ebx, %ebx
movzbl (%rsi), %r14d
leal -0x30(%r14), %r11d
cmpl $0xa, %r11d
jb 0x94761
leal -0x41(%r14), %r11d
cmpl $0x5, %r11d
ja 0x9474e
addl $-0x37, %r14d
jmp 0x9475e
leal -0x61(%r14), %r11d
addl $-0x57, %r14d
cmpl $0x6, %r11d
cmovael %r10d, %r14d
movl %r14d, %r11d
testl %r11d, %r11d
js 0x947b1
shll $0x4, %ebx
orl %ebx, %r11d
incq %rdx
incq %rsi
movl %r11d, %ebx
cmpq $0x4, %rdx
jne 0x94730
movl $0x4, %edx
jmp 0x947b4
movl $0xd, %edx
jmp 0x947f8
movl $0x9, %edx
jmp 0x947f8
movl $0xa, %edx
jmp 0x947f8
movl $0xb, %edx
jmp 0x947f8
movl $0x8, %edx
jmp 0x947f8
xorl %r9d, %r9d
jmp 0x947ee
xorl %r9d, %r9d
movl %esi, %edx
jmp 0x947ee
movl %ebx, %r11d
cmpl $0x4, %edx
jne 0x947ec
movl %r11d, %edx
andl $0xfffffc00, %edx # imm = 0xFFFFFC00
cmpl $0xdc00, %edx # imm = 0xDC00
jne 0x947ec
addq $0x7, %r8
shll $0xa, %eax
andl $0xffc00, %eax # imm = 0xFFC00
andl $0x3ff, %r11d # imm = 0x3FF
leal (%rax,%r11), %edx
addl $0x10000, %edx # imm = 0x10000
movq %r8, %rcx
jmp 0x947ee
movl %eax, %edx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testb %r9b, %r9b
je 0x947fd
movq %rcx, (%rdi)
movl %edx, %eax
popq %rbx
popq %r14
retq
| lre_parse_escape:
push r14
push rbx
mov r8, [rdi]
lea rcx, [r8+1]
movzx edx, byte ptr [r8]
mov eax, 0FFFFFFFEh
cmp edx, 61h ; 'a'
jg short loc_9458F
add edx, 0FFFFFFD0h
cmp edx, 8
jnb loc_947FD; jumptable 00000000000945AB cases 111-113,115,119
cmp esi, 2
jnz loc_9462E
mov eax, 0FFFFFFFFh
test edx, edx
jnz loc_947FD; jumptable 00000000000945AB cases 111-113,115,119
movzx esi, byte ptr [rcx]
add esi, 0FFFFFFC6h
xor edx, edx
cmp esi, 0FFFFFFF6h
jb loc_947F8
jmp loc_947FD; jumptable 00000000000945AB cases 111-113,115,119
loc_9458F:
lea r9d, [rdx-6Eh]; switch 11 cases
cmp r9d, 0Ah
ja def_945AB; jumptable 00000000000945AB default case
lea r10, jpt_945AB
movsxd r9, ds:(jpt_945AB - 0A3180h)[r10+r9*4]
add r9, r10
jmp r9; switch jump
loc_945AE:
test esi, esi; jumptable 00000000000945AB cases 117,120
jz loc_94687
cmp byte ptr [rcx], 7Bh ; '{'
jnz loc_94687
add r8, 3
xor edx, edx
mov eax, 0FFFFFFFFh
mov rcx, r8
loc_945CD:
movzx r8d, byte ptr [rcx-1]
lea esi, [r8-30h]
cmp esi, 0Ah
jb short loc_945FC
lea esi, [r8-41h]
cmp esi, 5
ja short loc_945EA
add r8d, 0FFFFFFC9h
jmp short loc_945F9
loc_945EA:
lea esi, [r8-61h]
add r8d, 0FFFFFFA9h
cmp esi, 6
cmovnb r8d, eax
loc_945F9:
mov esi, r8d
loc_945FC:
test esi, esi
js loc_947A5
shl edx, 4
or esi, edx
cmp esi, 10FFFFh
ja loc_947AA
lea r8, [rcx+1]
cmp byte ptr [rcx], 7Dh ; '}'
mov rcx, r8
mov edx, esi
jnz short loc_945CD
mov r9b, 1
mov rcx, r8
jmp loc_947AD
loc_9462E:
movzx eax, byte ptr [rcx]
add eax, 0FFFFFFD0h
cmp eax, 7
ja loc_947F8
lea edx, [rax+rdx*8]
lea rcx, [r8+2]
cmp edx, 1Fh
ja loc_947F8
movzx eax, byte ptr [rcx]
add eax, 0FFFFFFD0h
cmp eax, 7
ja loc_947F8
lea edx, [rax+rdx*8]
add r8, 3
mov rcx, r8
jmp loc_947F8
def_945AB:
cmp edx, 62h ; 'b'; jumptable 00000000000945AB default case
jz loc_9479E
cmp edx, 66h ; 'f'
jnz loc_947FD; jumptable 00000000000945AB cases 111-113,115,119
mov edx, 0Ch
jmp loc_947F8
loc_94687:
xor eax, eax
cmp edx, 78h ; 'x'
setnz al
lea r9d, ds:2[rax*2]
lea rbx, [r8+2]
xor r10d, r10d
mov r11d, 0FFFFFFFFh
xor edx, edx
loc_946A6:
mov rcx, rbx
movzx ebx, byte ptr [rbx-1]
lea eax, [rbx-30h]
cmp eax, 0Ah
jb short loc_946D1
lea eax, [rbx-41h]
cmp eax, 5
ja short loc_946C2
add ebx, 0FFFFFFC9h
jmp short loc_946CF
loc_946C2:
lea eax, [rbx-61h]
add ebx, 0FFFFFFA9h
cmp eax, 6
cmovnb ebx, r11d
loc_946CF:
mov eax, ebx
loc_946D1:
test eax, eax
js loc_947A5
shl edx, 4
or eax, edx
dec r10
lea rbx, [rcx+1]
mov edx, eax
dec r9d
jnz short loc_946A6
mov r9b, 1
cmp esi, 2
jnz loc_947EC
mov edx, eax
and edx, 0FFFFFC00h
cmp edx, 0D800h
jnz loc_947EC
cmp byte ptr [rbx-1], 5Ch ; '\'
jnz loc_947EC
cmp byte ptr [rbx], 75h ; 'u'
jnz loc_947EC
sub r8, r10
lea rsi, [r8+3]
xor edx, edx
mov r10d, 0FFFFFFFFh
xor ebx, ebx
loc_94730:
movzx r14d, byte ptr [rsi]
lea r11d, [r14-30h]
cmp r11d, 0Ah
jb short loc_94761
lea r11d, [r14-41h]
cmp r11d, 5
ja short loc_9474E
add r14d, 0FFFFFFC9h
jmp short loc_9475E
loc_9474E:
lea r11d, [r14-61h]
add r14d, 0FFFFFFA9h
cmp r11d, 6
cmovnb r14d, r10d
loc_9475E:
mov r11d, r14d
loc_94761:
test r11d, r11d
js short loc_947B1
shl ebx, 4
or r11d, ebx
inc rdx
inc rsi
mov ebx, r11d
cmp rdx, 4
jnz short loc_94730
mov edx, 4
jmp short loc_947B4
loc_94782:
mov edx, 0Dh; jumptable 00000000000945AB case 114
jmp short loc_947F8
loc_94789:
mov edx, 9; jumptable 00000000000945AB case 116
jmp short loc_947F8
loc_94790:
mov edx, 0Ah; jumptable 00000000000945AB case 110
jmp short loc_947F8
loc_94797:
mov edx, 0Bh; jumptable 00000000000945AB case 118
jmp short loc_947F8
loc_9479E:
mov edx, 8
jmp short loc_947F8
loc_947A5:
xor r9d, r9d
jmp short loc_947EE
loc_947AA:
xor r9d, r9d
loc_947AD:
mov edx, esi
jmp short loc_947EE
loc_947B1:
mov r11d, ebx
loc_947B4:
cmp edx, 4
jnz short loc_947EC
mov edx, r11d
and edx, 0FFFFFC00h
cmp edx, 0DC00h
jnz short loc_947EC
add r8, 7
shl eax, 0Ah
and eax, 0FFC00h
and r11d, 3FFh
lea edx, [rax+r11]
add edx, 10000h
mov rcx, r8
jmp short loc_947EE
loc_947EC:
mov edx, eax
loc_947EE:
mov eax, 0FFFFFFFFh
test r9b, r9b
jz short loc_947FD; jumptable 00000000000945AB cases 111-113,115,119
loc_947F8:
mov [rdi], rcx
mov eax, edx
loc_947FD:
pop rbx; jumptable 00000000000945AB cases 111-113,115,119
pop r14
retn
| long long lre_parse_escape(unsigned __int8 **a1, int a2)
{
_BYTE *v2; // r8
unsigned __int8 *v3; // rcx
unsigned int v4; // edx
long long result; // rax
unsigned int v6; // edx
int v7; // r8d
int v8; // esi
int v9; // r8d
unsigned int v10; // esi
unsigned int v11; // esi
unsigned __int8 *v12; // r8
bool v13; // zf
char v14; // r9
unsigned int v15; // eax
unsigned int v16; // eax
int v17; // r9d
unsigned __int8 *v18; // rbx
long long v19; // r10
int v20; // ebx
int v21; // eax
int v22; // ebx
unsigned int v23; // eax
int v24; // eax
_BYTE *v25; // r8
unsigned __int8 *v26; // rsi
long long v27; // rdx
int v28; // ebx
int v29; // r14d
int v30; // r11d
int v31; // r14d
unsigned int v32; // r11d
int v33; // r11d
v2 = *a1;
v3 = *a1 + 1;
v4 = **a1;
result = 4294967294LL;
if ( v4 <= 0x61 )
{
v6 = v4 - 48;
if ( v6 >= 8 )
return result;
if ( a2 == 2 )
{
result = 0xFFFFFFFFLL;
if ( v6 )
return result;
v6 = 0;
if ( (unsigned int)*v3 - 58 >= 0xFFFFFFF6 )
return result;
}
else
{
v15 = *v3 - 48;
if ( v15 <= 7 )
{
v6 = v15 + 8 * v6;
v3 = v2 + 2;
if ( v6 <= 0x1F )
{
v16 = *v3 - 48;
if ( v16 <= 7 )
{
v6 = v16 + 8 * v6;
v3 = v2 + 3;
}
}
}
}
LABEL_65:
*a1 = v3;
return v6;
}
switch ( **a1 )
{
case 'n':
v6 = 10;
goto LABEL_65;
case 'o':
case 'p':
case 'q':
case 's':
case 'w':
return result;
case 'r':
v6 = 13;
goto LABEL_65;
case 't':
v6 = 9;
goto LABEL_65;
case 'u':
case 'x':
if ( a2 && *v3 == 123 )
{
v6 = 0;
v3 = v2 + 3;
while ( 1 )
{
v7 = *(v3 - 1);
v8 = v7 - 48;
if ( (unsigned int)(v7 - 48) >= 0xA )
{
if ( (unsigned int)(v7 - 65) > 5 )
{
v10 = v7 - 97;
v9 = v7 - 87;
if ( v10 >= 6 )
v9 = -1;
}
else
{
v9 = v7 - 55;
}
v8 = v9;
}
if ( v8 < 0 )
goto LABEL_56;
v11 = (16 * v6) | v8;
if ( v11 > 0x10FFFF )
break;
v12 = v3 + 1;
v13 = *v3++ == 125;
v6 = v11;
if ( v13 )
{
v14 = 1;
v3 = v12;
LABEL_58:
v6 = v11;
goto LABEL_64;
}
}
v14 = 0;
goto LABEL_58;
}
v17 = 2 * (v4 != 120) + 2;
v18 = v2 + 2;
v19 = 0LL;
v6 = 0;
do
{
v3 = v18;
v20 = *(v18 - 1);
v21 = v20 - 48;
if ( (unsigned int)(v20 - 48) >= 0xA )
{
if ( (unsigned int)(v20 - 65) > 5 )
{
v23 = v20 - 97;
v22 = v20 - 87;
if ( v23 >= 6 )
v22 = -1;
}
else
{
v22 = v20 - 55;
}
v21 = v22;
}
if ( v21 < 0 )
{
LABEL_56:
v14 = 0;
goto LABEL_64;
}
v24 = (16 * v6) | v21;
--v19;
v18 = v3 + 1;
v6 = v24;
--v17;
}
while ( v17 );
v14 = 1;
if ( a2 != 2 || (v24 & 0xFFFFFC00) != 0xD800 || *v3 != 92 || *v18 != 117 )
goto LABEL_63;
v25 = &v2[-v19];
v26 = v25 + 3;
v27 = 0LL;
v28 = 0;
break;
case 'v':
v6 = 11;
goto LABEL_65;
default:
if ( v4 == 98 )
{
v6 = 8;
}
else
{
if ( v4 != 102 )
return result;
v6 = 12;
}
goto LABEL_65;
}
while ( 1 )
{
v29 = *v26;
v30 = v29 - 48;
if ( (unsigned int)(v29 - 48) >= 0xA )
{
if ( (unsigned int)(v29 - 65) > 5 )
{
v32 = v29 - 97;
v31 = v29 - 87;
if ( v32 >= 6 )
v31 = -1;
}
else
{
v31 = v29 - 55;
}
v30 = v31;
}
if ( v30 < 0 )
break;
v33 = (16 * v28) | v30;
++v27;
++v26;
v28 = v33;
if ( v27 == 4 )
{
LODWORD(v27) = 4;
goto LABEL_60;
}
}
v33 = v28;
LABEL_60:
if ( (_DWORD)v27 == 4 && (v33 & 0xFFFFFC00) == 0xDC00 )
{
v6 = ((v24 << 10) & 0xFFC00) + (v33 & 0x3FF) + 0x10000;
v3 = v25 + 7;
}
else
{
LABEL_63:
v6 = v24;
}
LABEL_64:
result = 0xFFFFFFFFLL;
if ( v14 )
goto LABEL_65;
return result;
}
| |||
51,223 | lre_parse_escape | bluesky950520[P]quickjs/libregexp.c | int lre_parse_escape(const uint8_t **pp, int allow_utf16)
{
const uint8_t *p;
uint32_t c;
p = *pp;
c = *p++;
switch(c) {
case 'b':
c = '\b';
break;
case 'f':
c = '\f';
break;
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'v':
c = '\v';
break;
case 'x':
case 'u':
{
int h, n, i;
uint32_t c1;
if (*p == '{' && allow_utf16) {
p++;
c = 0;
for(;;) {
h = from_hex(*p++);
if (h < 0)
return -1;
c = (c << 4) | h;
if (c > 0x10FFFF)
return -1;
if (*p == '}')
break;
}
p++;
} else {
if (c == 'x') {
n = 2;
} else {
n = 4;
}
c = 0;
for(i = 0; i < n; i++) {
h = from_hex(*p++);
if (h < 0) {
return -1;
}
c = (c << 4) | h;
}
if (is_hi_surrogate(c) &&
allow_utf16 == 2 && p[0] == '\\' && p[1] == 'u') {
/* convert an escaped surrogate pair into a
unicode char */
c1 = 0;
for(i = 0; i < 4; i++) {
h = from_hex(p[2 + i]);
if (h < 0)
break;
c1 = (c1 << 4) | h;
}
if (i == 4 && is_lo_surrogate(c1)) {
p += 6;
c = from_surrogate(c, c1);
}
}
}
}
break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
c -= '0';
if (allow_utf16 == 2) {
/* only accept \0 not followed by digit */
if (c != 0 || lre_is_digit(*p))
return -1;
} else {
/* parse a legacy octal sequence */
uint32_t v;
v = *p - '0';
if (v > 7)
break;
c = (c << 3) | v;
p++;
if (c >= 32)
break;
v = *p - '0';
if (v > 7)
break;
c = (c << 3) | v;
p++;
}
break;
default:
return -2;
}
*pp = p;
return c;
} | O2 | c | lre_parse_escape:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %r13
leaq 0x1(%r13), %r12
movzbl (%r13), %eax
leal -0x30(%rax), %r15d
cmpl $0x8, %r15d
jb 0x7b9d8
pushq $-0x2
popq %rbp
leal -0x6e(%rax), %ecx
cmpl $0xa, %ecx
ja 0x7ba40
leaq 0xe74a(%rip), %rdx # 0x8a0c0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
testl %r14d, %r14d
je 0x7ba4e
cmpb $0x7b, (%r12)
jne 0x7ba4e
movb 0x2(%r13), %al
addq $0x3, %r13
xorl %r15d, %r15d
pushq $-0x1
popq %rbp
movq %r13, %r12
movzbl %al, %edi
callq 0x7bb67
testl %eax, %eax
js 0x7bab7
shll $0x4, %r15d
orl %eax, %r15d
cmpl $0x10ffff, %r15d # imm = 0x10FFFF
ja 0x7bab7
movb (%r12), %al
incq %r12
cmpb $0x7d, %al
jne 0x7b9a4
jmp 0x7bab1
cmpl $0x2, %r14d
jne 0x7ba03
pushq $-0x1
popq %rbp
testl %r15d, %r15d
jne 0x7bab7
movzbl (%r12), %eax
addl $-0x3a, %eax
xorl %r15d, %r15d
cmpl $-0xa, %eax
jb 0x7bab1
jmp 0x7bab7
movzbl (%r12), %eax
addl $-0x30, %eax
cmpl $0x7, %eax
ja 0x7bab1
leal (%rax,%r15,8), %r15d
leaq 0x2(%r13), %r12
cmpl $0x1f, %r15d
ja 0x7bab1
movzbl (%r12), %eax
addl $-0x30, %eax
cmpl $0x7, %eax
ja 0x7bab1
leal (%rax,%r15,8), %r15d
addq $0x3, %r13
movq %r13, %r12
jmp 0x7bab1
cmpl $0x62, %eax
je 0x7baad
cmpl $0x66, %eax
jne 0x7bab7
pushq $0xc
jmp 0x7baaf
movq %rbx, (%rsp)
xorl %ecx, %ecx
cmpl $0x78, %eax
setne %cl
leal 0x2(,%rcx,2), %eax
movq %rax, 0x10(%rsp)
addl %ecx, %ecx
leaq (%rcx,%r13), %rax
addq $0x3, %rax
movq %rax, 0x8(%rsp)
xorl %ebx, %ebx
pushq $-0x1
popq %rbp
xorl %r15d, %r15d
cmpl %ebx, 0x10(%rsp)
je 0x7bac8
movzbl (%r12,%rbx), %edi
callq 0x7bb67
testl %eax, %eax
js 0x7bab7
shll $0x4, %r15d
orl %eax, %r15d
incq %rbx
jmp 0x7ba7d
pushq $0xd
jmp 0x7baaf
pushq $0xb
jmp 0x7baaf
pushq $0x9
jmp 0x7baaf
pushq $0xa
jmp 0x7baaf
pushq $0x8
popq %r15
movq %r12, (%rbx)
movl %r15d, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %r14d
jne 0x7bb27
movl %r15d, %eax
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
cmpl $0xd800, %eax # imm = 0xD800
movq (%rsp), %rbx
movq 0x8(%rsp), %rbp
jne 0x7bb22
cmpb $0x5c, (%rbp)
jne 0x7bb22
cmpb $0x75, 0x1(%rbp)
jne 0x7bb22
movq 0x10(%rsp), %rax
leaq (%rax,%r13), %r14
addq $0x3, %r14
xorl %r12d, %r12d
xorl %ebx, %ebx
cmpq $0x4, %r12
je 0x7bb2e
movzbl (%r14,%r12), %edi
callq 0x7bb67
testl %eax, %eax
js 0x7bb5b
shll $0x4, %ebx
orl %eax, %ebx
incq %r12
jmp 0x7bb04
movq %rbp, %r12
jmp 0x7bab1
movq 0x8(%rsp), %r12
jmp 0x7bb5e
movl %ebx, %eax
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
cmpl $0xdc00, %eax # imm = 0xDC00
jne 0x7bb5b
addq $0x6, %rbp
shll $0xa, %r15d
andl $0xffc00, %r15d # imm = 0xFFC00
andl $0x3ff, %ebx # imm = 0x3FF
addl %ebx, %r15d
addl $0x10000, %r15d # imm = 0x10000
movq %rbp, %r12
movq (%rsp), %rbx
jmp 0x7bab1
| lre_parse_escape:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14d, esi
mov rbx, rdi
mov r13, [rdi]
lea r12, [r13+1]
movzx eax, byte ptr [r13+0]
lea r15d, [rax-30h]
cmp r15d, 8
jb short loc_7B9D8
push 0FFFFFFFFFFFFFFFEh
pop rbp
lea ecx, [rax-6Eh]; switch 11 cases
cmp ecx, 0Ah
ja def_7B97D; jumptable 000000000007B97D default case
lea rdx, jpt_7B97D
movsxd rcx, ds:(jpt_7B97D - 8A0C0h)[rdx+rcx*4]
add rcx, rdx
jmp rcx; switch jump
loc_7B97F:
test r14d, r14d; jumptable 000000000007B97D cases 117,120
jz loc_7BA4E
cmp byte ptr [r12], 7Bh ; '{'
jnz loc_7BA4E
mov al, [r13+2]
add r13, 3
xor r15d, r15d
push 0FFFFFFFFFFFFFFFFh
pop rbp
mov r12, r13
loc_7B9A4:
movzx edi, al
call from_hex_0
test eax, eax
js loc_7BAB7; jumptable 000000000007B97D cases 111-113,115,119
shl r15d, 4
or r15d, eax
cmp r15d, 10FFFFh
ja loc_7BAB7; jumptable 000000000007B97D cases 111-113,115,119
mov al, [r12]
inc r12
cmp al, 7Dh ; '}'
jnz short loc_7B9A4
jmp loc_7BAB1
loc_7B9D8:
cmp r14d, 2
jnz short loc_7BA03
push 0FFFFFFFFFFFFFFFFh
pop rbp
test r15d, r15d
jnz loc_7BAB7; jumptable 000000000007B97D cases 111-113,115,119
movzx eax, byte ptr [r12]
add eax, 0FFFFFFC6h
xor r15d, r15d
cmp eax, 0FFFFFFF6h
jb loc_7BAB1
jmp loc_7BAB7; jumptable 000000000007B97D cases 111-113,115,119
loc_7BA03:
movzx eax, byte ptr [r12]
add eax, 0FFFFFFD0h
cmp eax, 7
ja loc_7BAB1
lea r15d, [rax+r15*8]
lea r12, [r13+2]
cmp r15d, 1Fh
ja loc_7BAB1
movzx eax, byte ptr [r12]
add eax, 0FFFFFFD0h
cmp eax, 7
ja short loc_7BAB1
lea r15d, [rax+r15*8]
add r13, 3
mov r12, r13
jmp short loc_7BAB1
def_7B97D:
cmp eax, 62h ; 'b'; jumptable 000000000007B97D default case
jz short loc_7BAAD
cmp eax, 66h ; 'f'
jnz short loc_7BAB7; jumptable 000000000007B97D cases 111-113,115,119
push 0Ch
jmp short loc_7BAAF
loc_7BA4E:
mov [rsp+48h+var_48], rbx
xor ecx, ecx
cmp eax, 78h ; 'x'
setnz cl
lea eax, ds:2[rcx*2]
mov [rsp+48h+var_38], rax
add ecx, ecx
lea rax, [rcx+r13]
add rax, 3
mov [rsp+48h+var_40], rax
xor ebx, ebx
push 0FFFFFFFFFFFFFFFFh
pop rbp
xor r15d, r15d
loc_7BA7D:
cmp dword ptr [rsp+48h+var_38], ebx
jz short loc_7BAC8
movzx edi, byte ptr [r12+rbx]
call from_hex_0
test eax, eax
js short loc_7BAB7; jumptable 000000000007B97D cases 111-113,115,119
shl r15d, 4
or r15d, eax
inc rbx
jmp short loc_7BA7D
loc_7BA9D:
push 0Dh; jumptable 000000000007B97D case 114
jmp short loc_7BAAF
loc_7BAA1:
push 0Bh; jumptable 000000000007B97D case 118
jmp short loc_7BAAF
loc_7BAA5:
push 9; jumptable 000000000007B97D case 116
jmp short loc_7BAAF
loc_7BAA9:
push 0Ah; jumptable 000000000007B97D case 110
jmp short loc_7BAAF
loc_7BAAD:
push 8
loc_7BAAF:
pop r15
loc_7BAB1:
mov [rbx], r12
mov ebp, r15d
loc_7BAB7:
mov eax, ebp; jumptable 000000000007B97D cases 111-113,115,119
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7BAC8:
cmp r14d, 2
jnz short loc_7BB27
mov eax, r15d
and eax, 0FFFFFC00h
cmp eax, 0D800h
mov rbx, [rsp+48h+var_48]
mov rbp, [rsp+48h+var_40]
jnz short loc_7BB22
cmp byte ptr [rbp+0], 5Ch ; '\'
jnz short loc_7BB22
cmp byte ptr [rbp+1], 75h ; 'u'
jnz short loc_7BB22
mov rax, [rsp+48h+var_38]
lea r14, [rax+r13]
add r14, 3
xor r12d, r12d
xor ebx, ebx
loc_7BB04:
cmp r12, 4
jz short loc_7BB2E
movzx edi, byte ptr [r14+r12]
call from_hex_0
test eax, eax
js short loc_7BB5B
shl ebx, 4
or ebx, eax
inc r12
jmp short loc_7BB04
loc_7BB22:
mov r12, rbp
jmp short loc_7BAB1
loc_7BB27:
mov r12, [rsp+48h+var_40]
jmp short loc_7BB5E
loc_7BB2E:
mov eax, ebx
and eax, 0FFFFFC00h
cmp eax, 0DC00h
jnz short loc_7BB5B
add rbp, 6
shl r15d, 0Ah
and r15d, 0FFC00h
and ebx, 3FFh
add r15d, ebx
add r15d, 10000h
loc_7BB5B:
mov r12, rbp
loc_7BB5E:
mov rbx, [rsp+48h+var_48]
jmp loc_7BAB1
| long long lre_parse_escape(unsigned __int8 **a1, int a2)
{
unsigned __int8 **v2; // rbx
unsigned __int8 *v3; // r13
unsigned __int8 *v4; // r12
int v5; // eax
unsigned int v6; // r15d
unsigned int v7; // ebp
unsigned __int8 v8; // al
int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
BOOL v12; // ecx
long long v13; // rbx
int v14; // eax
unsigned __int8 *v16; // rbp
long long v17; // r12
int v18; // ebx
int v19; // eax
int v20; // [rsp-8h] [rbp-50h]
unsigned __int8 *v21; // [rsp+8h] [rbp-40h]
long long v22; // [rsp+10h] [rbp-38h]
v2 = a1;
v3 = *a1;
v4 = *a1 + 1;
v5 = **a1;
v6 = v5 - 48;
if ( (unsigned int)(v5 - 48) < 8 )
{
if ( a2 == 2 )
{
v7 = -1;
if ( v5 != 48 )
return v7;
v6 = 0;
if ( (unsigned int)*v4 - 58 >= 0xFFFFFFF6 )
return v7;
}
else
{
v10 = *v4 - 48;
if ( v10 <= 7 )
{
v6 = v10 + 8 * v6;
v4 = v3 + 2;
if ( v6 <= 0x1F )
{
v11 = *v4 - 48;
if ( v11 <= 7 )
{
v6 = v11 + 8 * v6;
v4 = v3 + 3;
}
}
}
}
LABEL_31:
*v2 = v4;
return v6;
}
v7 = -2;
switch ( **a1 )
{
case 'n':
v20 = 10;
goto LABEL_30;
case 'o':
case 'p':
case 'q':
case 's':
case 'w':
return v7;
case 'r':
v20 = 13;
goto LABEL_30;
case 't':
v20 = 9;
goto LABEL_30;
case 'u':
case 'x':
if ( !a2 || *v4 != 123 )
{
v12 = v5 != 120;
v22 = (unsigned int)(2 * v12 + 2);
v21 = &v3[2 * v12 + 3];
v13 = 0LL;
v7 = -1;
v6 = 0;
while ( (_DWORD)v22 != (_DWORD)v13 )
{
v14 = from_hex_0(v4[v13]);
if ( v14 < 0 )
return v7;
v6 = v14 | (16 * v6);
++v13;
}
if ( a2 == 2 )
{
v2 = a1;
v16 = v21;
if ( (v6 & 0xFFFFFC00) != 0xD800 || *v21 != 92 || v21[1] != 117 )
{
v4 = v21;
goto LABEL_31;
}
v17 = 0LL;
v18 = 0;
while ( v17 != 4 )
{
v19 = from_hex_0(v3[v22 + 3 + v17]);
if ( v19 < 0 )
goto LABEL_45;
v18 = v19 | (16 * v18);
++v17;
}
if ( (v18 & 0xFFFFFC00) == 0xDC00 )
{
v16 = v21 + 6;
v6 = (v18 & 0x3FF) + ((v6 << 10) & 0xFFC00) + 0x10000;
}
LABEL_45:
v4 = v16;
}
else
{
v4 = v21;
}
v2 = a1;
goto LABEL_31;
}
v8 = v3[2];
v6 = 0;
v7 = -1;
v4 = v3 + 3;
while ( 1 )
{
v9 = from_hex_0(v8);
if ( v9 < 0 )
break;
v6 = v9 | (16 * v6);
if ( v6 > 0x10FFFF )
break;
v8 = *v4++;
if ( v8 == 125 )
goto LABEL_31;
}
break;
case 'v':
v20 = 11;
goto LABEL_30;
default:
if ( v5 == 98 )
{
v20 = 8;
}
else
{
if ( v5 != 102 )
return v7;
v20 = 12;
}
LABEL_30:
v6 = v20;
goto LABEL_31;
}
return v7;
}
| lre_parse_escape:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14D,ESI
MOV RBX,RDI
MOV R13,qword ptr [RDI]
LEA R12,[R13 + 0x1]
MOVZX EAX,byte ptr [R13]
LEA R15D,[RAX + -0x30]
CMP R15D,0x8
JC 0x0017b9d8
PUSH -0x2
POP RBP
LEA ECX,[RAX + -0x6e]
CMP ECX,0xa
JA 0x0017ba40
LEA RDX,[0x18a0c0]
MOVSXD RCX,dword ptr [RDX + RCX*0x4]
ADD RCX,RDX
switchD:
JMP RCX
caseD_75:
TEST R14D,R14D
JZ 0x0017ba4e
CMP byte ptr [R12],0x7b
JNZ 0x0017ba4e
MOV AL,byte ptr [R13 + 0x2]
ADD R13,0x3
XOR R15D,R15D
PUSH -0x1
POP RBP
MOV R12,R13
LAB_0017b9a4:
MOVZX EDI,AL
CALL 0x0017bb67
TEST EAX,EAX
JS 0x0017bab7
SHL R15D,0x4
OR R15D,EAX
CMP R15D,0x10ffff
JA 0x0017bab7
MOV AL,byte ptr [R12]
INC R12
CMP AL,0x7d
JNZ 0x0017b9a4
JMP 0x0017bab1
LAB_0017b9d8:
CMP R14D,0x2
JNZ 0x0017ba03
PUSH -0x1
POP RBP
TEST R15D,R15D
JNZ 0x0017bab7
MOVZX EAX,byte ptr [R12]
ADD EAX,-0x3a
XOR R15D,R15D
CMP EAX,-0xa
JC 0x0017bab1
JMP 0x0017bab7
LAB_0017ba03:
MOVZX EAX,byte ptr [R12]
ADD EAX,-0x30
CMP EAX,0x7
JA 0x0017bab1
LEA R15D,[RAX + R15*0x8]
LEA R12,[R13 + 0x2]
CMP R15D,0x1f
JA 0x0017bab1
MOVZX EAX,byte ptr [R12]
ADD EAX,-0x30
CMP EAX,0x7
JA 0x0017bab1
LEA R15D,[RAX + R15*0x8]
ADD R13,0x3
MOV R12,R13
JMP 0x0017bab1
default:
CMP EAX,0x62
JZ 0x0017baad
CMP EAX,0x66
JNZ 0x0017bab7
PUSH 0xc
JMP 0x0017baaf
LAB_0017ba4e:
MOV qword ptr [RSP],RBX
XOR ECX,ECX
CMP EAX,0x78
SETNZ CL
LEA EAX,[0x2 + RCX*0x2]
MOV qword ptr [RSP + 0x10],RAX
ADD ECX,ECX
LEA RAX,[RCX + R13*0x1]
ADD RAX,0x3
MOV qword ptr [RSP + 0x8],RAX
XOR EBX,EBX
PUSH -0x1
POP RBP
XOR R15D,R15D
LAB_0017ba7d:
CMP dword ptr [RSP + 0x10],EBX
JZ 0x0017bac8
MOVZX EDI,byte ptr [R12 + RBX*0x1]
CALL 0x0017bb67
TEST EAX,EAX
JS 0x0017bab7
SHL R15D,0x4
OR R15D,EAX
INC RBX
JMP 0x0017ba7d
caseD_72:
PUSH 0xd
JMP 0x0017baaf
caseD_76:
PUSH 0xb
JMP 0x0017baaf
caseD_74:
PUSH 0x9
JMP 0x0017baaf
caseD_6e:
PUSH 0xa
JMP 0x0017baaf
LAB_0017baad:
PUSH 0x8
LAB_0017baaf:
POP R15
LAB_0017bab1:
MOV qword ptr [RBX],R12
MOV EBP,R15D
caseD_6f:
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017bac8:
CMP R14D,0x2
JNZ 0x0017bb27
MOV EAX,R15D
AND EAX,0xfffffc00
CMP EAX,0xd800
MOV RBX,qword ptr [RSP]
MOV RBP,qword ptr [RSP + 0x8]
JNZ 0x0017bb22
CMP byte ptr [RBP],0x5c
JNZ 0x0017bb22
CMP byte ptr [RBP + 0x1],0x75
JNZ 0x0017bb22
MOV RAX,qword ptr [RSP + 0x10]
LEA R14,[RAX + R13*0x1]
ADD R14,0x3
XOR R12D,R12D
XOR EBX,EBX
LAB_0017bb04:
CMP R12,0x4
JZ 0x0017bb2e
MOVZX EDI,byte ptr [R14 + R12*0x1]
CALL 0x0017bb67
TEST EAX,EAX
JS 0x0017bb5b
SHL EBX,0x4
OR EBX,EAX
INC R12
JMP 0x0017bb04
LAB_0017bb22:
MOV R12,RBP
JMP 0x0017bab1
LAB_0017bb27:
MOV R12,qword ptr [RSP + 0x8]
JMP 0x0017bb5e
LAB_0017bb2e:
MOV EAX,EBX
AND EAX,0xfffffc00
CMP EAX,0xdc00
JNZ 0x0017bb5b
ADD RBP,0x6
SHL R15D,0xa
AND R15D,0xffc00
AND EBX,0x3ff
ADD R15D,EBX
ADD R15D,0x10000
LAB_0017bb5b:
MOV R12,RBP
LAB_0017bb5e:
MOV RBX,qword ptr [RSP]
JMP 0x0017bab1
|
uint lre_parse_escape(long *param_1,int param_2)
{
byte *pbVar1;
byte bVar2;
uint uVar3;
uint uVar4;
uint uVar5;
byte *pbVar6;
long lVar7;
byte *pbVar8;
uint uVar9;
bool bVar10;
pbVar1 = (byte *)*param_1;
pbVar8 = pbVar1 + 1;
bVar2 = *pbVar1;
uVar9 = bVar2 - 0x30;
if (uVar9 < 8) {
if (param_2 == 2) {
if (uVar9 != 0) {
return 0xffffffff;
}
uVar9 = 0;
if (0xfffffff5 < *pbVar8 - 0x3a) {
return 0xffffffff;
}
}
else if (*pbVar8 - 0x30 < 8) {
uVar9 = (*pbVar8 - 0x30) + uVar9 * 8;
pbVar8 = pbVar1 + 2;
if ((uVar9 < 0x20) && (*pbVar8 - 0x30 < 8)) {
uVar9 = (*pbVar8 - 0x30) + uVar9 * 8;
pbVar8 = pbVar1 + 3;
}
}
}
else {
uVar9 = 0xfffffffe;
switch(bVar2) {
case 0x6e:
uVar9 = 10;
break;
case 0x6f:
case 0x70:
case 0x71:
case 0x73:
case 0x77:
goto switchD_0017b97d_caseD_6f;
case 0x72:
uVar9 = 0xd;
break;
case 0x74:
uVar9 = 9;
break;
case 0x75:
case 0x78:
if ((param_2 == 0) || (*pbVar8 != 0x7b)) {
bVar10 = bVar2 != 0x78;
uVar3 = (uint)bVar10 * 2 + 2;
pbVar6 = pbVar1 + (ulong)((uint)bVar10 * 2) + 3;
uVar9 = 0;
for (lVar7 = 0; uVar3 != (uint)lVar7; lVar7 = lVar7 + 1) {
uVar4 = from_hex(pbVar8[lVar7]);
if ((int)uVar4 < 0) {
return 0xffffffff;
}
uVar9 = uVar9 << 4 | uVar4;
}
pbVar8 = pbVar6;
if ((((param_2 == 2) && ((uVar9 & 0xfffffc00) == 0xd800)) && (*pbVar6 == 0x5c)) &&
(pbVar1[(ulong)((uint)bVar10 * 2) + 4] == 0x75)) {
uVar4 = 0;
for (lVar7 = 0; lVar7 != 4; lVar7 = lVar7 + 1) {
uVar5 = from_hex(pbVar1[lVar7 + (ulong)uVar3 + 3]);
if ((int)uVar5 < 0) goto LAB_0017bab1;
uVar4 = uVar4 << 4 | uVar5;
}
if ((uVar4 & 0xfffffc00) == 0xdc00) {
pbVar8 = pbVar1 + (ulong)((uint)bVar10 * 2) + 9;
uVar9 = (uVar9 & 0x3ff) * 0x400 + (uVar4 & 0x3ff) + 0x10000;
}
}
}
else {
bVar2 = pbVar1[2];
pbVar8 = pbVar1 + 3;
uVar9 = 0;
do {
uVar3 = from_hex(bVar2);
if ((int)uVar3 < 0) {
return 0xffffffff;
}
uVar9 = uVar9 << 4 | uVar3;
if (0x10ffff < uVar9) {
return 0xffffffff;
}
bVar2 = *pbVar8;
pbVar8 = pbVar8 + 1;
} while (bVar2 != 0x7d);
}
break;
case 0x76:
uVar9 = 0xb;
break;
default:
if (bVar2 == 0x62) {
uVar9 = 8;
}
else {
if (bVar2 != 0x66) {
return 0xfffffffe;
}
uVar9 = 0xc;
}
}
}
LAB_0017bab1:
*param_1 = (long)pbVar8;
switchD_0017b97d_caseD_6f:
return uVar9;
}
| |
51,224 | ma_tls_set_certs | eloqsql/libmariadb/libmariadb/secure/openssl.c | static int ma_tls_set_certs(MYSQL *mysql, SSL_CTX *ctx)
{
char *certfile= mysql->options.ssl_cert,
*keyfile= mysql->options.ssl_key;
char *pw= (mysql->options.extension) ?
mysql->options.extension->tls_pw : NULL;
/* add cipher */
if ((mysql->options.ssl_cipher &&
mysql->options.ssl_cipher[0] != 0))
{
if(
#ifdef TLS1_3_VERSION
SSL_CTX_set_ciphersuites(ctx, mysql->options.ssl_cipher) == 0 &&
#endif
SSL_CTX_set_cipher_list(ctx, mysql->options.ssl_cipher) == 0)
goto error;
}
/* ca_file and ca_path */
if (!SSL_CTX_load_verify_locations(ctx,
mysql->options.ssl_ca,
mysql->options.ssl_capath))
{
if (mysql->options.ssl_ca || mysql->options.ssl_capath)
goto error;
if (SSL_CTX_set_default_verify_paths(ctx) == 0)
goto error;
}
if (mysql->options.extension &&
(mysql->options.extension->ssl_crl || mysql->options.extension->ssl_crlpath))
{
X509_STORE *certstore;
if ((certstore= SSL_CTX_get_cert_store(ctx)))
{
if (X509_STORE_load_locations(certstore, mysql->options.extension->ssl_crl,
mysql->options.extension->ssl_crlpath) == 0)
goto error;
if (X509_STORE_set_flags(certstore, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL) == 0)
goto error;
}
}
if (keyfile && !certfile)
certfile= keyfile;
if (certfile && !keyfile)
keyfile= certfile;
/* set cert */
if (certfile && certfile[0] != 0)
{
if (SSL_CTX_use_certificate_chain_file(ctx, certfile) != 1)
{
goto error;
}
}
if (keyfile && keyfile[0])
{
FILE *fp;
if ((fp= fopen(keyfile, "rb")))
{
EVP_PKEY *key= EVP_PKEY_new();
PEM_read_PrivateKey(fp, &key, NULL, pw);
fclose(fp);
if (SSL_CTX_use_PrivateKey(ctx, key) != 1)
{
unsigned long err= ERR_peek_error();
EVP_PKEY_free(key);
if (!(ERR_GET_LIB(err) == ERR_LIB_X509 &&
ERR_GET_REASON(err) == X509_R_CERT_ALREADY_IN_HASH_TABLE))
goto error;
}
EVP_PKEY_free(key);
} else {
my_set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
CER(CR_FILE_NOT_FOUND), keyfile);
return 1;
}
}
/* verify key */
if (certfile && SSL_CTX_check_private_key(ctx) != 1)
goto error;
SSL_CTX_set_verify(ctx, (mysql->options.ssl_ca || mysql->options.ssl_capath) ?
SSL_VERIFY_PEER : SSL_VERIFY_NONE, NULL);
return 0;
error:
ma_tls_set_error(mysql);
return 1;
} | O0 | c | ma_tls_set_certs:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x400(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x3c754
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x3c75c
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x3c75c
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x420(%rax)
je 0x3c7be
movq -0x10(%rbp), %rax
movq 0x420(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3c7be
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x420(%rax), %rsi
callq 0x13500
cmpl $0x0, %eax
jne 0x3c7bc
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x420(%rax), %rsi
callq 0x13400
cmpl $0x0, %eax
jne 0x3c7bc
jmp 0x3ca52
jmp 0x3c7be
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x410(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x418(%rax), %rdx
callq 0x13550
cmpl $0x0, %eax
jne 0x3c818
movq -0x10(%rbp), %rax
cmpq $0x0, 0x410(%rax)
jne 0x3c7fe
movq -0x10(%rbp), %rax
cmpq $0x0, 0x418(%rax)
je 0x3c803
jmp 0x3ca52
movq -0x18(%rbp), %rdi
callq 0x134a0
cmpl $0x0, %eax
jne 0x3c816
jmp 0x3ca52
jmp 0x3c818
movq -0x10(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x3c8ae
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3c84e
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x3c8ae
movq -0x18(%rbp), %rdi
callq 0x137d0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x3c8ac
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
movq 0x18(%rax), %rdx
callq 0x13800
cmpl $0x0, %eax
jne 0x3c892
jmp 0x3ca52
movq -0x38(%rbp), %rdi
movl $0xc, %esi
callq 0x132f0
cmpl $0x0, %eax
jne 0x3c8aa
jmp 0x3ca52
jmp 0x3c8ac
jmp 0x3c8ae
cmpq $0x0, -0x28(%rbp)
je 0x3c8c4
cmpq $0x0, -0x20(%rbp)
jne 0x3c8c4
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3c8da
cmpq $0x0, -0x28(%rbp)
jne 0x3c8da
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3c906
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3c906
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13350
cmpl $0x1, %eax
je 0x3c904
jmp 0x3ca52
jmp 0x3c906
cmpq $0x0, -0x28(%rbp)
je 0x3c9e8
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3c9e8
movq -0x28(%rbp), %rdi
leaq 0x1662a(%rip), %rsi # 0x52f56
callq 0x134d0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x3c9b4
callq 0x13740
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rcx
leaq -0x48(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x132e0
movq -0x40(%rbp), %rdi
callq 0x13420
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x13380
cmpl $0x1, %eax
je 0x3c9a9
callq 0x130c0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x132b0
movq -0x50(%rbp), %rdi
callq 0x3d580
cmpl $0xb, %eax
jne 0x3c9a2
movq -0x50(%rbp), %rdi
callq 0x3d5c0
cmpl $0x65, %eax
je 0x3c9a7
jmp 0x3ca52
jmp 0x3c9a9
movq -0x48(%rbp), %rdi
callq 0x132b0
jmp 0x3c9e6
movq -0x10(%rbp), %rdi
leaq 0x2a881(%rip), %rax # 0x67240
movq (%rax), %rdx
leaq 0x2aa87(%rip), %rax # 0x67450
movq 0x20(%rax), %rcx
movq -0x28(%rbp), %r8
movl $0x7ea, %esi # imm = 0x7EA
movb $0x0, %al
callq 0x1bae0
movl $0x1, -0x4(%rbp)
jmp 0x3ca62
jmp 0x3c9e8
cmpq $0x0, -0x20(%rbp)
je 0x3c9ff
movq -0x18(%rbp), %rdi
callq 0x13710
cmpl $0x1, %eax
je 0x3c9ff
jmp 0x3ca52
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x410(%rcx)
movb %al, -0x59(%rbp)
jne 0x3ca2c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x418(%rax)
setne %al
movb %al, -0x59(%rbp)
movq -0x68(%rbp), %rdi
movb -0x59(%rbp), %cl
xorl %esi, %esi
movl $0x1, %eax
testb $0x1, %cl
cmovnel %eax, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13120
movl $0x0, -0x4(%rbp)
jmp 0x3ca62
movq -0x10(%rbp), %rdi
callq 0x3ccb0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| ma_tls_set_certs:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax+408h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax+400h]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
cmp qword ptr [rax+480h], 0
jz short loc_3C754
mov rax, [rbp+var_10]
mov rax, [rax+480h]
mov rax, [rax+0A0h]
mov [rbp+var_58], rax
jmp short loc_3C75C
loc_3C754:
xor eax, eax
mov [rbp+var_58], rax
jmp short $+2
loc_3C75C:
mov rax, [rbp+var_58]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
cmp qword ptr [rax+420h], 0
jz short loc_3C7BE
mov rax, [rbp+var_10]
mov rax, [rax+420h]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_3C7BE
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+420h]
call _SSL_CTX_set_ciphersuites
cmp eax, 0
jnz short loc_3C7BC
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+420h]
call _SSL_CTX_set_cipher_list
cmp eax, 0
jnz short loc_3C7BC
jmp loc_3CA52
loc_3C7BC:
jmp short $+2
loc_3C7BE:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+410h]
mov rax, [rbp+var_10]
mov rdx, [rax+418h]
call _SSL_CTX_load_verify_locations
cmp eax, 0
jnz short loc_3C818
mov rax, [rbp+var_10]
cmp qword ptr [rax+410h], 0
jnz short loc_3C7FE
mov rax, [rbp+var_10]
cmp qword ptr [rax+418h], 0
jz short loc_3C803
loc_3C7FE:
jmp loc_3CA52
loc_3C803:
mov rdi, [rbp+var_18]
call _SSL_CTX_set_default_verify_paths
cmp eax, 0
jnz short loc_3C816
jmp loc_3CA52
loc_3C816:
jmp short $+2
loc_3C818:
mov rax, [rbp+var_10]
cmp qword ptr [rax+480h], 0
jz loc_3C8AE
mov rax, [rbp+var_10]
mov rax, [rax+480h]
cmp qword ptr [rax+10h], 0
jnz short loc_3C84E
mov rax, [rbp+var_10]
mov rax, [rax+480h]
cmp qword ptr [rax+18h], 0
jz short loc_3C8AE
loc_3C84E:
mov rdi, [rbp+var_18]
call _SSL_CTX_get_cert_store
mov [rbp+var_38], rax
cmp rax, 0
jz short loc_3C8AC
mov rdi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rax, [rax+480h]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rax, [rax+480h]
mov rdx, [rax+18h]
call _X509_STORE_load_locations
cmp eax, 0
jnz short loc_3C892
jmp loc_3CA52
loc_3C892:
mov rdi, [rbp+var_38]
mov esi, 0Ch
call _X509_STORE_set_flags
cmp eax, 0
jnz short loc_3C8AA
jmp loc_3CA52
loc_3C8AA:
jmp short $+2
loc_3C8AC:
jmp short $+2
loc_3C8AE:
cmp [rbp+var_28], 0
jz short loc_3C8C4
cmp [rbp+var_20], 0
jnz short loc_3C8C4
mov rax, [rbp+var_28]
mov [rbp+var_20], rax
loc_3C8C4:
cmp [rbp+var_20], 0
jz short loc_3C8DA
cmp [rbp+var_28], 0
jnz short loc_3C8DA
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
loc_3C8DA:
cmp [rbp+var_20], 0
jz short loc_3C906
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_3C906
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call _SSL_CTX_use_certificate_chain_file
cmp eax, 1
jz short loc_3C904
jmp loc_3CA52
loc_3C904:
jmp short $+2
loc_3C906:
cmp [rbp+var_28], 0
jz loc_3C9E8
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, 0
jz loc_3C9E8
mov rdi, [rbp+var_28]
lea rsi, aRb; "rb"
call _fopen64
mov [rbp+var_40], rax
cmp rax, 0
jz short loc_3C9B4
call _EVP_PKEY_new
mov [rbp+var_48], rax
mov rdi, [rbp+var_40]
mov rcx, [rbp+var_30]
lea rsi, [rbp+var_48]
xor eax, eax
mov edx, eax
call _PEM_read_PrivateKey
mov rdi, [rbp+var_40]
call _fclose
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_48]
call _SSL_CTX_use_PrivateKey
cmp eax, 1
jz short loc_3C9A9
call _ERR_peek_error
mov [rbp+var_50], rax
mov rdi, [rbp+var_48]
call _EVP_PKEY_free
mov rdi, [rbp+var_50]
call ERR_GET_LIB
cmp eax, 0Bh
jnz short loc_3C9A2
mov rdi, [rbp+var_50]
call ERR_GET_REASON
cmp eax, 65h ; 'e'
jz short loc_3C9A7
loc_3C9A2:
jmp loc_3CA52
loc_3C9A7:
jmp short $+2
loc_3C9A9:
mov rdi, [rbp+var_48]
call _EVP_PKEY_free
jmp short loc_3C9E6
loc_3C9B4:
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, mariadb_client_errors
mov rcx, [rax+20h]
mov r8, [rbp+var_28]
mov esi, 7EAh
mov al, 0
call my_set_error
mov [rbp+var_4], 1
jmp short loc_3CA62
loc_3C9E6:
jmp short $+2
loc_3C9E8:
cmp [rbp+var_20], 0
jz short loc_3C9FF
mov rdi, [rbp+var_18]
call _SSL_CTX_check_private_key
cmp eax, 1
jz short loc_3C9FF
jmp short loc_3CA52
loc_3C9FF:
mov rax, [rbp+var_18]
mov [rbp+var_68], rax
mov rcx, [rbp+var_10]
mov al, 1
cmp qword ptr [rcx+410h], 0
mov [rbp+var_59], al
jnz short loc_3CA2C
mov rax, [rbp+var_10]
cmp qword ptr [rax+418h], 0
setnz al
mov [rbp+var_59], al
loc_3CA2C:
mov rdi, [rbp+var_68]
mov cl, [rbp+var_59]
xor esi, esi
mov eax, 1
test cl, 1
cmovnz esi, eax
xor eax, eax
mov edx, eax
call _SSL_CTX_set_verify
mov [rbp+var_4], 0
jmp short loc_3CA62
loc_3CA52:
mov rdi, [rbp+var_10]
call ma_tls_set_error
mov [rbp+var_4], 1
loc_3CA62:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
| long long ma_tls_set_certs(_QWORD *a1, long long a2)
{
bool v3; // [rsp+17h] [rbp-59h]
long long v4; // [rsp+18h] [rbp-58h]
long long v5; // [rsp+20h] [rbp-50h]
long long v6; // [rsp+28h] [rbp-48h] BYREF
long long v7; // [rsp+30h] [rbp-40h]
long long cert_store; // [rsp+38h] [rbp-38h]
long long v9; // [rsp+40h] [rbp-30h]
_BYTE *v10; // [rsp+48h] [rbp-28h]
_BYTE *v11; // [rsp+50h] [rbp-20h]
long long v12; // [rsp+58h] [rbp-18h]
_QWORD *v13; // [rsp+60h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = (_BYTE *)a1[129];
v10 = (_BYTE *)a1[128];
if ( a1[144] )
v4 = *(_QWORD *)(v13[144] + 160LL);
else
v4 = 0LL;
v9 = v4;
if ( v13[132]
&& *(_BYTE *)v13[132]
&& !(unsigned int)SSL_CTX_set_ciphersuites(v12, v13[132])
&& !(unsigned int)SSL_CTX_set_cipher_list(v12, v13[132]) )
{
goto LABEL_42;
}
if ( !(unsigned int)SSL_CTX_load_verify_locations(v12, v13[130], v13[131])
&& (v13[130] || v13[131] || !(unsigned int)SSL_CTX_set_default_verify_paths(v12)) )
{
goto LABEL_42;
}
if ( v13[144] && (*(_QWORD *)(v13[144] + 16LL) || *(_QWORD *)(v13[144] + 24LL)) )
{
cert_store = SSL_CTX_get_cert_store(v12);
if ( cert_store )
{
if ( !(unsigned int)X509_STORE_load_locations(
cert_store,
*(_QWORD *)(v13[144] + 16LL),
*(_QWORD *)(v13[144] + 24LL))
|| !(unsigned int)X509_STORE_set_flags(cert_store, 12LL) )
{
goto LABEL_42;
}
}
}
if ( v10 && !v11 )
v11 = v10;
if ( v11 && !v10 )
v10 = v11;
if ( v11 && *v11 && (unsigned int)SSL_CTX_use_certificate_chain_file(v12, v11) != 1 )
goto LABEL_42;
if ( v10 && *v10 )
{
v7 = fopen64(v10, "rb");
if ( !v7 )
{
my_set_error((long long)v13, 0x7EAu, (long long)SQLSTATE_UNKNOWN, (long long)mariadb_client_errors[4], v10);
return 1;
}
v6 = EVP_PKEY_new();
PEM_read_PrivateKey(v7, &v6, 0LL, v9);
fclose(v7);
if ( (unsigned int)SSL_CTX_use_PrivateKey(v12, v6) != 1 )
{
v5 = ERR_peek_error();
EVP_PKEY_free(v6);
if ( (unsigned int)ERR_GET_LIB(v5) != 11 || (unsigned int)ERR_GET_REASON(v5) != 101 )
goto LABEL_42;
}
EVP_PKEY_free(v6);
}
if ( v11 && (unsigned int)SSL_CTX_check_private_key(v12) != 1 )
{
LABEL_42:
ma_tls_set_error(v13);
return 1;
}
v3 = 1;
if ( !v13[130] )
v3 = v13[131] != 0LL;
SSL_CTX_set_verify(v12, v3, 0LL);
return 0;
}
| ma_tls_set_certs:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x408]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x400]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x0013c754
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0xa0]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0013c75c
LAB_0013c754:
XOR EAX,EAX
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0013c75c
LAB_0013c75c:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x420],0x0
JZ 0x0013c7be
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x420]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0013c7be
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x420]
CALL 0x00113500
CMP EAX,0x0
JNZ 0x0013c7bc
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x420]
CALL 0x00113400
CMP EAX,0x0
JNZ 0x0013c7bc
JMP 0x0013ca52
LAB_0013c7bc:
JMP 0x0013c7be
LAB_0013c7be:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x410]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x418]
CALL 0x00113550
CMP EAX,0x0
JNZ 0x0013c818
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x410],0x0
JNZ 0x0013c7fe
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x418],0x0
JZ 0x0013c803
LAB_0013c7fe:
JMP 0x0013ca52
LAB_0013c803:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001134a0
CMP EAX,0x0
JNZ 0x0013c816
JMP 0x0013ca52
LAB_0013c816:
JMP 0x0013c818
LAB_0013c818:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x0013c8ae
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x10],0x0
JNZ 0x0013c84e
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x0013c8ae
LAB_0013c84e:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001137d0
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x0013c8ac
MOV RDI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x00113800
CMP EAX,0x0
JNZ 0x0013c892
JMP 0x0013ca52
LAB_0013c892:
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,0xc
CALL 0x001132f0
CMP EAX,0x0
JNZ 0x0013c8aa
JMP 0x0013ca52
LAB_0013c8aa:
JMP 0x0013c8ac
LAB_0013c8ac:
JMP 0x0013c8ae
LAB_0013c8ae:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0013c8c4
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0013c8c4
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x20],RAX
LAB_0013c8c4:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0013c8da
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x0013c8da
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
LAB_0013c8da:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0013c906
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0013c906
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00113350
CMP EAX,0x1
JZ 0x0013c904
JMP 0x0013ca52
LAB_0013c904:
JMP 0x0013c906
LAB_0013c906:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0013c9e8
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0013c9e8
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[0x152f56]
CALL 0x001134d0
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JZ 0x0013c9b4
CALL 0x00113740
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0x48]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001132e0
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00113420
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00113380
CMP EAX,0x1
JZ 0x0013c9a9
CALL 0x001130c0
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x001132b0
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0013d580
CMP EAX,0xb
JNZ 0x0013c9a2
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0013d5c0
CMP EAX,0x65
JZ 0x0013c9a7
LAB_0013c9a2:
JMP 0x0013ca52
LAB_0013c9a7:
JMP 0x0013c9a9
LAB_0013c9a9:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x001132b0
JMP 0x0013c9e6
LAB_0013c9b4:
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x167240]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x167450]
MOV RCX,qword ptr [RAX + 0x20]
MOV R8,qword ptr [RBP + -0x28]
MOV ESI,0x7ea
MOV AL,0x0
CALL 0x0011bae0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013ca62
LAB_0013c9e6:
JMP 0x0013c9e8
LAB_0013c9e8:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0013c9ff
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00113710
CMP EAX,0x1
JZ 0x0013c9ff
JMP 0x0013ca52
LAB_0013c9ff:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x68],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV AL,0x1
CMP qword ptr [RCX + 0x410],0x0
MOV byte ptr [RBP + -0x59],AL
JNZ 0x0013ca2c
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x418],0x0
SETNZ AL
MOV byte ptr [RBP + -0x59],AL
LAB_0013ca2c:
MOV RDI,qword ptr [RBP + -0x68]
MOV CL,byte ptr [RBP + -0x59]
XOR ESI,ESI
MOV EAX,0x1
TEST CL,0x1
CMOVNZ ESI,EAX
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00113120
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013ca62
LAB_0013ca52:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013ccb0
MOV dword ptr [RBP + -0x4],0x1
LAB_0013ca62:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int4 ma_tls_set_certs(long param_1,SSL_CTX *param_2)
{
int iVar1;
ulong uVar2;
bool bVar3;
void *local_60;
EVP_PKEY *local_50;
FILE *local_48;
X509_STORE *local_40;
void *local_38;
char *local_30;
char *local_28;
SSL_CTX *local_20;
long local_18;
local_28 = *(char **)(param_1 + 0x408);
local_30 = *(char **)(param_1 + 0x400);
if (*(long *)(param_1 + 0x480) == 0) {
local_60 = (void *)0x0;
}
else {
local_60 = *(void **)(*(long *)(param_1 + 0x480) + 0xa0);
}
local_38 = local_60;
local_20 = param_2;
local_18 = param_1;
if ((((((*(long *)(param_1 + 0x420) == 0) || (**(char **)(param_1 + 0x420) == '\0')) ||
(iVar1 = SSL_CTX_set_ciphersuites(param_2,*(int8 *)(param_1 + 0x420)), iVar1 != 0)) ||
(iVar1 = SSL_CTX_set_cipher_list(local_20,*(char **)(local_18 + 0x420)), iVar1 != 0)) &&
((iVar1 = SSL_CTX_load_verify_locations
(local_20,*(char **)(local_18 + 0x410),*(char **)(local_18 + 0x418)),
iVar1 != 0 ||
(((*(long *)(local_18 + 0x410) == 0 && (*(long *)(local_18 + 0x418) == 0)) &&
(iVar1 = SSL_CTX_set_default_verify_paths(local_20), iVar1 != 0)))))) &&
((((*(long *)(local_18 + 0x480) == 0 ||
((*(long *)(*(long *)(local_18 + 0x480) + 0x10) == 0 &&
(*(long *)(*(long *)(local_18 + 0x480) + 0x18) == 0)))) ||
(local_40 = SSL_CTX_get_cert_store(local_20), local_40 == (X509_STORE *)0x0)) ||
((iVar1 = X509_STORE_load_locations
(local_40,*(char **)(*(long *)(local_18 + 0x480) + 0x10),
*(char **)(*(long *)(local_18 + 0x480) + 0x18)), iVar1 != 0 &&
(iVar1 = X509_STORE_set_flags(local_40,0xc), iVar1 != 0)))))) {
if ((local_30 != (char *)0x0) && (local_28 == (char *)0x0)) {
local_28 = local_30;
}
if ((local_28 != (char *)0x0) && (local_30 == (char *)0x0)) {
local_30 = local_28;
}
if (((local_28 == (char *)0x0) || (*local_28 == '\0')) ||
(iVar1 = SSL_CTX_use_certificate_chain_file(local_20,local_28), iVar1 == 1)) {
if ((local_30 != (char *)0x0) && (*local_30 != '\0')) {
local_48 = fopen64(local_30,"rb");
if (local_48 == (FILE *)0x0) {
my_set_error(local_18,0x7ea,SQLSTATE_UNKNOWN,mariadb_client_errors._32_8_,local_30);
return 1;
}
local_50 = EVP_PKEY_new();
PEM_read_PrivateKey(local_48,&local_50,(int1 *)0x0,local_38);
fclose(local_48);
iVar1 = SSL_CTX_use_PrivateKey(local_20,local_50);
if (iVar1 != 1) {
uVar2 = ERR_peek_error();
EVP_PKEY_free(local_50);
iVar1 = ERR_GET_LIB(uVar2);
if ((iVar1 != 0xb) || (iVar1 = ERR_GET_REASON(uVar2), iVar1 != 0x65)) goto LAB_0013ca52;
}
EVP_PKEY_free(local_50);
}
if ((local_28 == (char *)0x0) || (iVar1 = SSL_CTX_check_private_key(local_20), iVar1 == 1)) {
bVar3 = true;
if (*(long *)(local_18 + 0x410) == 0) {
bVar3 = *(long *)(local_18 + 0x418) != 0;
}
SSL_CTX_set_verify(local_20,(uint)bVar3,(callback *)0x0);
return 0;
}
}
}
LAB_0013ca52:
ma_tls_set_error(local_18);
return 1;
}
| |
51,225 | unlink_deleted_block | eloqsql/storage/myisam/mi_dynrec.c | static my_bool unlink_deleted_block(MI_INFO *info, MI_BLOCK_INFO *block_info)
{
DBUG_ENTER("unlink_deleted_block");
if (block_info->filepos == info->s->state.dellink)
{
/* First deleted block; We can just use this ! */
info->s->state.dellink=block_info->next_filepos;
}
else
{
MI_BLOCK_INFO tmp;
tmp.second_read=0;
/* Unlink block from the previous block */
if (!(_mi_get_block_info(&tmp,info->dfile,block_info->prev_filepos)
& BLOCK_DELETED))
DBUG_RETURN(1); /* Something is wrong */
mi_sizestore(tmp.header+4,block_info->next_filepos);
if (info->s->file_write(info, tmp.header+4,8,
block_info->prev_filepos+4, MYF(MY_NABP)))
DBUG_RETURN(1);
/* Unlink block from next block */
if (block_info->next_filepos != HA_OFFSET_ERROR)
{
if (!(_mi_get_block_info(&tmp,info->dfile,block_info->next_filepos)
& BLOCK_DELETED))
DBUG_RETURN(1); /* Something is wrong */
mi_sizestore(tmp.header+12,block_info->prev_filepos);
if (info->s->file_write(info, tmp.header+12,8,
block_info->next_filepos+12,
MYF(MY_NABP)))
DBUG_RETURN(1);
}
}
/* We now have one less deleted block */
info->state->del--;
info->state->empty-= block_info->block_len;
info->s->state.split--;
/*
If this was a block that we where accessing through table scan
(mi_rrnd() or mi_scan(), then ensure that we skip over this block
when doing next mi_rrnd() or mi_scan().
*/
if (info->nextpos == block_info->filepos)
info->nextpos+=block_info->block_len;
DBUG_RETURN(0);
} | O0 | c | unlink_deleted_block:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x70(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x58(%rcx), %rax
jne 0xaa4ad
movq -0x78(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x58(%rax)
jmp 0xaa6ee
movl $0x0, -0x10(%rbp)
movq -0x70(%rbp), %rax
movl 0x1c0(%rax), %esi
movq -0x78(%rbp), %rax
movq 0x48(%rax), %rdx
leaq -0x60(%rbp), %rdi
callq 0xa9a50
andl $0x4, %eax
cmpl $0x0, %eax
jne 0xaa4e2
jmp 0xaa4d9
movb $0x1, -0x61(%rbp)
jmp 0xaa765
movq -0x78(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x20, %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movb %al, -0x59(%rbp)
movq -0x90(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x5a(%rbp)
movq -0x90(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x5b(%rbp)
movq -0x90(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x5c(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movb %al, -0x55(%rbp)
movq -0x98(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x56(%rbp)
movq -0x98(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x57(%rbp)
movq -0x98(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x58(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x2e8(%rax), %rax
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
addq $0x4, %rsi
movq -0x78(%rbp), %rcx
movq 0x48(%rcx), %rcx
addq $0x4, %rcx
movl $0x8, %edx
movl $0x4, %r8d
callq *%rax
cmpq $0x0, %rax
je 0xaa5c6
jmp 0xaa5bd
movb $0x1, -0x61(%rbp)
jmp 0xaa765
movq -0x78(%rbp), %rax
cmpq $-0x1, 0x40(%rax)
je 0xaa6ec
movq -0x70(%rbp), %rax
movl 0x1c0(%rax), %esi
movq -0x78(%rbp), %rax
movq 0x40(%rax), %rdx
leaq -0x60(%rbp), %rdi
callq 0xa9a50
andl $0x4, %eax
cmpl $0x0, %eax
jne 0xaa603
jmp 0xaa5fa
movb $0x1, -0x61(%rbp)
jmp 0xaa765
movq -0x78(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x78(%rbp), %rax
movq 0x48(%rax), %rax
shrq $0x20, %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movb %al, -0x51(%rbp)
movq -0xb0(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x52(%rbp)
movq -0xb0(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x53(%rbp)
movq -0xb0(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x54(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movb %al, -0x4d(%rbp)
movq -0xb8(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x4e(%rbp)
movq -0xb8(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x4f(%rbp)
movq -0xb8(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x50(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x2e8(%rax), %rax
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
addq $0xc, %rsi
movq -0x78(%rbp), %rcx
movq 0x40(%rcx), %rcx
addq $0xc, %rcx
movl $0x8, %edx
movl $0x4, %r8d
callq *%rax
cmpq $0x0, %rax
je 0xaa6ea
jmp 0xaa6e4
movb $0x1, -0x61(%rbp)
jmp 0xaa765
jmp 0xaa6ec
jmp 0xaa6ee
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x78(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x50(%rax)
movq -0x70(%rbp), %rax
movq 0x178(%rax), %rax
movq -0x78(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jne 0xaa75f
movq -0x78(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x70(%rbp), %rax
addq 0x178(%rax), %rcx
movq %rcx, 0x178(%rax)
jmp 0xaa761
movb $0x0, -0x61(%rbp)
movb -0x61(%rbp), %al
movb %al, -0xb9(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xaa78f
movb -0xb9(%rbp), %al
addq $0xc0, %rsp
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
| unlink_deleted_block_0:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov rax, [rbp+var_78]
mov rax, [rax+38h]
mov rcx, [rbp+var_70]
mov rcx, [rcx]
cmp rax, [rcx+58h]
jnz short loc_AA4AD
mov rax, [rbp+var_78]
mov rcx, [rax+40h]
mov rax, [rbp+var_70]
mov rax, [rax]
mov [rax+58h], rcx
jmp loc_AA6EE
loc_AA4AD:
mov [rbp+var_10], 0
mov rax, [rbp+var_70]
mov esi, [rax+1C0h]
mov rax, [rbp+var_78]
mov rdx, [rax+48h]
lea rdi, [rbp+var_60]
call _mi_get_block_info
and eax, 4
cmp eax, 0
jnz short loc_AA4E2
jmp short $+2
loc_AA4D9:
mov [rbp+var_61], 1
jmp loc_AA765
loc_AA4E2:
mov rax, [rbp+var_78]
mov rax, [rax+40h]
mov [rbp+var_80], rax
mov rax, [rbp+var_78]
mov rax, [rax+40h]
shr rax, 20h
mov [rbp+var_88], rax
mov rax, [rbp+var_88]
mov [rbp+var_90], rax
mov rax, [rbp+var_90]
mov [rbp+var_59], al
mov rax, [rbp+var_90]
shr rax, 8
mov [rbp+var_5A], al
mov rax, [rbp+var_90]
shr rax, 10h
mov [rbp+var_5B], al
mov rax, [rbp+var_90]
shr rax, 18h
mov [rbp+var_5C], al
mov rax, [rbp+var_80]
mov [rbp+var_98], rax
mov rax, [rbp+var_98]
mov [rbp+var_55], al
mov rax, [rbp+var_98]
shr rax, 8
mov [rbp+var_56], al
mov rax, [rbp+var_98]
shr rax, 10h
mov [rbp+var_57], al
mov rax, [rbp+var_98]
shr rax, 18h
mov [rbp+var_58], al
mov rax, [rbp+var_70]
mov rax, [rax]
mov rax, [rax+2E8h]
mov rdi, [rbp+var_70]
lea rsi, [rbp+var_60]
add rsi, 4
mov rcx, [rbp+var_78]
mov rcx, [rcx+48h]
add rcx, 4
mov edx, 8
mov r8d, 4
call rax
cmp rax, 0
jz short loc_AA5C6
jmp short $+2
loc_AA5BD:
mov [rbp+var_61], 1
jmp loc_AA765
loc_AA5C6:
mov rax, [rbp+var_78]
cmp qword ptr [rax+40h], 0FFFFFFFFFFFFFFFFh
jz loc_AA6EC
mov rax, [rbp+var_70]
mov esi, [rax+1C0h]
mov rax, [rbp+var_78]
mov rdx, [rax+40h]
lea rdi, [rbp+var_60]
call _mi_get_block_info
and eax, 4
cmp eax, 0
jnz short loc_AA603
jmp short $+2
loc_AA5FA:
mov [rbp+var_61], 1
jmp loc_AA765
loc_AA603:
mov rax, [rbp+var_78]
mov rax, [rax+48h]
mov [rbp+var_A0], rax
mov rax, [rbp+var_78]
mov rax, [rax+48h]
shr rax, 20h
mov [rbp+var_A8], rax
mov rax, [rbp+var_A8]
mov [rbp+var_B0], rax
mov rax, [rbp+var_B0]
mov [rbp+var_51], al
mov rax, [rbp+var_B0]
shr rax, 8
mov [rbp+var_52], al
mov rax, [rbp+var_B0]
shr rax, 10h
mov [rbp+var_53], al
mov rax, [rbp+var_B0]
shr rax, 18h
mov [rbp+var_54], al
mov rax, [rbp+var_A0]
mov [rbp+var_B8], rax
mov rax, [rbp+var_B8]
mov [rbp+var_4D], al
mov rax, [rbp+var_B8]
shr rax, 8
mov [rbp+var_4E], al
mov rax, [rbp+var_B8]
shr rax, 10h
mov [rbp+var_4F], al
mov rax, [rbp+var_B8]
shr rax, 18h
mov [rbp+var_50], al
mov rax, [rbp+var_70]
mov rax, [rax]
mov rax, [rax+2E8h]
mov rdi, [rbp+var_70]
lea rsi, [rbp+var_60]
add rsi, 0Ch
mov rcx, [rbp+var_78]
mov rcx, [rcx+40h]
add rcx, 0Ch
mov edx, 8
mov r8d, 4
call rax
cmp rax, 0
jz short loc_AA6EA
jmp short $+2
loc_AA6E4:
mov [rbp+var_61], 1
jmp short loc_AA765
loc_AA6EA:
jmp short $+2
loc_AA6EC:
jmp short $+2
loc_AA6EE:
mov rax, [rbp+var_70]
mov rax, [rax+8]
mov rcx, [rax+8]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+8], rcx
mov rax, [rbp+var_78]
mov rdx, [rax+28h]
mov rax, [rbp+var_70]
mov rax, [rax+8]
mov rcx, [rax+10h]
sub rcx, rdx
mov [rax+10h], rcx
mov rax, [rbp+var_70]
mov rax, [rax]
mov rcx, [rax+50h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+50h], rcx
mov rax, [rbp+var_70]
mov rax, [rax+178h]
mov rcx, [rbp+var_78]
cmp rax, [rcx+38h]
jnz short loc_AA75F
mov rax, [rbp+var_78]
mov rcx, [rax+28h]
mov rax, [rbp+var_70]
add rcx, [rax+178h]
mov [rax+178h], rcx
loc_AA75F:
jmp short $+2
loc_AA761:
mov [rbp+var_61], 0
loc_AA765:
mov al, [rbp+var_61]
mov [rbp+var_B9], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_AA78F
mov al, [rbp+var_B9]
add rsp, 0C0h
pop rbp
retn
loc_AA78F:
call ___stack_chk_fail
| char unlink_deleted_block_0(_QWORD *a1, _QWORD *a2)
{
long long v3; // [rsp+20h] [rbp-A0h]
long long v4; // [rsp+40h] [rbp-80h]
char v6[4]; // [rsp+60h] [rbp-60h] BYREF
_BYTE v7[8]; // [rsp+64h] [rbp-5Ch] BYREF
_BYTE v8[68]; // [rsp+6Ch] [rbp-54h] BYREF
int v9; // [rsp+B0h] [rbp-10h]
unsigned long long v10; // [rsp+B8h] [rbp-8h]
v10 = __readfsqword(0x28u);
if ( a2[7] == *(_QWORD *)(*a1 + 88LL) )
{
*(_QWORD *)(*a1 + 88LL) = a2[8];
}
else
{
v9 = 0;
if ( (mi_get_block_info(v6, (const char *)*((unsigned int *)a1 + 112), a2[9]) & 4) == 0 )
return 1;
v4 = a2[8];
v7[2] = BYTE5(v4);
v7[3] = BYTE4(v4);
v7[0] = HIBYTE(v4);
v7[1] = BYTE6(v4);
v7[6] = BYTE1(v4);
v7[7] = v4;
v7[4] = BYTE3(v4);
v7[5] = BYTE2(v4);
if ( (*(long long ( **)(_QWORD *, _BYTE *, long long, long long, long long))(*a1 + 744LL))(
a1,
v7,
8LL,
a2[9] + 4LL,
4LL) )
{
return 1;
}
if ( a2[8] != -1LL )
{
if ( (mi_get_block_info(v6, (const char *)*((unsigned int *)a1 + 112), a2[8]) & 4) == 0 )
return 1;
v3 = a2[9];
v8[2] = BYTE5(v3);
v8[3] = BYTE4(v3);
v8[0] = HIBYTE(v3);
v8[1] = BYTE6(v3);
v8[6] = BYTE1(v3);
v8[7] = v3;
v8[4] = BYTE3(v3);
v8[5] = BYTE2(v3);
if ( (*(long long ( **)(_QWORD *, _BYTE *, long long, long long, long long))(*a1 + 744LL))(
a1,
v8,
8LL,
a2[8] + 12LL,
4LL) )
{
return 1;
}
}
}
--*(_QWORD *)(a1[1] + 8LL);
*(_QWORD *)(a1[1] + 16LL) -= a2[5];
--*(_QWORD *)(*a1 + 80LL);
if ( a1[47] == a2[7] )
a1[47] += a2[5];
return 0;
}
| unlink_deleted_block:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x78],RSI
MOV RAX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RCX]
CMP RAX,qword ptr [RCX + 0x58]
JNZ 0x001aa4ad
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x58],RCX
JMP 0x001aa6ee
LAB_001aa4ad:
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x70]
MOV ESI,dword ptr [RAX + 0x1c0]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RAX + 0x48]
LEA RDI,[RBP + -0x60]
CALL 0x001a9a50
AND EAX,0x4
CMP EAX,0x0
JNZ 0x001aa4e2
JMP 0x001aa4d9
LAB_001aa4d9:
MOV byte ptr [RBP + -0x61],0x1
JMP 0x001aa765
LAB_001aa4e2:
MOV RAX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RAX + 0x40]
SHR RAX,0x20
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV byte ptr [RBP + -0x59],AL
MOV RAX,qword ptr [RBP + -0x90]
SHR RAX,0x8
MOV byte ptr [RBP + -0x5a],AL
MOV RAX,qword ptr [RBP + -0x90]
SHR RAX,0x10
MOV byte ptr [RBP + -0x5b],AL
MOV RAX,qword ptr [RBP + -0x90]
SHR RAX,0x18
MOV byte ptr [RBP + -0x5c],AL
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x98]
MOV byte ptr [RBP + -0x55],AL
MOV RAX,qword ptr [RBP + -0x98]
SHR RAX,0x8
MOV byte ptr [RBP + -0x56],AL
MOV RAX,qword ptr [RBP + -0x98]
SHR RAX,0x10
MOV byte ptr [RBP + -0x57],AL
MOV RAX,qword ptr [RBP + -0x98]
SHR RAX,0x18
MOV byte ptr [RBP + -0x58],AL
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x2e8]
MOV RDI,qword ptr [RBP + -0x70]
LEA RSI,[RBP + -0x60]
ADD RSI,0x4
MOV RCX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RCX + 0x48]
ADD RCX,0x4
MOV EDX,0x8
MOV R8D,0x4
CALL RAX
CMP RAX,0x0
JZ 0x001aa5c6
JMP 0x001aa5bd
LAB_001aa5bd:
MOV byte ptr [RBP + -0x61],0x1
JMP 0x001aa765
LAB_001aa5c6:
MOV RAX,qword ptr [RBP + -0x78]
CMP qword ptr [RAX + 0x40],-0x1
JZ 0x001aa6ec
MOV RAX,qword ptr [RBP + -0x70]
MOV ESI,dword ptr [RAX + 0x1c0]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RAX + 0x40]
LEA RDI,[RBP + -0x60]
CALL 0x001a9a50
AND EAX,0x4
CMP EAX,0x0
JNZ 0x001aa603
JMP 0x001aa5fa
LAB_001aa5fa:
MOV byte ptr [RBP + -0x61],0x1
JMP 0x001aa765
LAB_001aa603:
MOV RAX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RAX + 0x48]
SHR RAX,0x20
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0xb0]
MOV byte ptr [RBP + -0x51],AL
MOV RAX,qword ptr [RBP + -0xb0]
SHR RAX,0x8
MOV byte ptr [RBP + -0x52],AL
MOV RAX,qword ptr [RBP + -0xb0]
SHR RAX,0x10
MOV byte ptr [RBP + -0x53],AL
MOV RAX,qword ptr [RBP + -0xb0]
SHR RAX,0x18
MOV byte ptr [RBP + -0x54],AL
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0xb8]
MOV byte ptr [RBP + -0x4d],AL
MOV RAX,qword ptr [RBP + -0xb8]
SHR RAX,0x8
MOV byte ptr [RBP + -0x4e],AL
MOV RAX,qword ptr [RBP + -0xb8]
SHR RAX,0x10
MOV byte ptr [RBP + -0x4f],AL
MOV RAX,qword ptr [RBP + -0xb8]
SHR RAX,0x18
MOV byte ptr [RBP + -0x50],AL
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x2e8]
MOV RDI,qword ptr [RBP + -0x70]
LEA RSI,[RBP + -0x60]
ADD RSI,0xc
MOV RCX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RCX + 0x40]
ADD RCX,0xc
MOV EDX,0x8
MOV R8D,0x4
CALL RAX
CMP RAX,0x0
JZ 0x001aa6ea
JMP 0x001aa6e4
LAB_001aa6e4:
MOV byte ptr [RBP + -0x61],0x1
JMP 0x001aa765
LAB_001aa6ea:
JMP 0x001aa6ec
LAB_001aa6ec:
JMP 0x001aa6ee
LAB_001aa6ee:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,RDX
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x50]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x50],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x178]
MOV RCX,qword ptr [RBP + -0x78]
CMP RAX,qword ptr [RCX + 0x38]
JNZ 0x001aa75f
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x70]
ADD RCX,qword ptr [RAX + 0x178]
MOV qword ptr [RAX + 0x178],RCX
LAB_001aa75f:
JMP 0x001aa761
LAB_001aa761:
MOV byte ptr [RBP + -0x61],0x0
LAB_001aa765:
MOV AL,byte ptr [RBP + -0x61]
MOV byte ptr [RBP + -0xb9],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001aa78f
MOV AL,byte ptr [RBP + -0xb9]
ADD RSP,0xc0
POP RBP
RET
LAB_001aa78f:
CALL 0x0012a250
|
int8 unlink_deleted_block(long *param_1,long param_2)
{
int8 uVar1;
int8 uVar2;
uint uVar3;
long lVar4;
long in_FS_OFFSET;
int1 local_69;
int1 local_68 [4];
int1 local_64;
int1 local_63;
int1 local_62;
int1 local_61;
int1 local_60;
int1 local_5f;
int1 local_5e;
int1 local_5d;
int1 local_5c;
int1 local_5b;
int1 local_5a;
int1 local_59;
int1 local_58;
int1 local_57;
int1 local_56;
int1 local_55;
int4 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (*(long *)(param_2 + 0x38) == *(long *)(*param_1 + 0x58)) {
*(int8 *)(*param_1 + 0x58) = *(int8 *)(param_2 + 0x40);
}
else {
local_18 = 0;
uVar3 = _mi_get_block_info(local_68,(int)param_1[0x38],*(int8 *)(param_2 + 0x48));
if ((uVar3 & 4) == 0) {
local_69 = 1;
goto LAB_001aa765;
}
uVar1 = *(int8 *)(param_2 + 0x40);
uVar2 = *(int8 *)(param_2 + 0x40);
local_61 = (int1)((ulong)uVar2 >> 0x20);
local_62 = (int1)((ulong)uVar2 >> 0x28);
local_63 = (int1)((ulong)uVar2 >> 0x30);
local_64 = (int1)((ulong)uVar2 >> 0x38);
local_5d = (int1)uVar1;
local_5e = (int1)((ulong)uVar1 >> 8);
local_5f = (int1)((ulong)uVar1 >> 0x10);
local_60 = (int1)((ulong)uVar1 >> 0x18);
lVar4 = (**(code **)(*param_1 + 0x2e8))(param_1,&local_64,8,*(long *)(param_2 + 0x48) + 4,4);
if (lVar4 != 0) {
local_69 = 1;
goto LAB_001aa765;
}
if (*(long *)(param_2 + 0x40) != -1) {
uVar3 = _mi_get_block_info(local_68,(int)param_1[0x38],*(int8 *)(param_2 + 0x40));
if ((uVar3 & 4) == 0) {
local_69 = 1;
goto LAB_001aa765;
}
uVar1 = *(int8 *)(param_2 + 0x48);
uVar2 = *(int8 *)(param_2 + 0x48);
local_59 = (int1)((ulong)uVar2 >> 0x20);
local_5a = (int1)((ulong)uVar2 >> 0x28);
local_5b = (int1)((ulong)uVar2 >> 0x30);
local_5c = (int1)((ulong)uVar2 >> 0x38);
local_55 = (int1)uVar1;
local_56 = (int1)((ulong)uVar1 >> 8);
local_57 = (int1)((ulong)uVar1 >> 0x10);
local_58 = (int1)((ulong)uVar1 >> 0x18);
lVar4 = (**(code **)(*param_1 + 0x2e8))(param_1,&local_5c,8,*(long *)(param_2 + 0x40) + 0xc,4)
;
if (lVar4 != 0) {
local_69 = 1;
goto LAB_001aa765;
}
}
}
*(long *)(param_1[1] + 8) = *(long *)(param_1[1] + 8) + -1;
*(long *)(param_1[1] + 0x10) = *(long *)(param_1[1] + 0x10) - *(long *)(param_2 + 0x28);
*(long *)(*param_1 + 0x50) = *(long *)(*param_1 + 0x50) + -1;
if (param_1[0x2f] == *(long *)(param_2 + 0x38)) {
param_1[0x2f] = *(long *)(param_2 + 0x28) + param_1[0x2f];
}
local_69 = 0;
LAB_001aa765:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_69);
}
| |
51,226 | unlink_deleted_block | eloqsql/storage/myisam/mi_dynrec.c | static my_bool unlink_deleted_block(MI_INFO *info, MI_BLOCK_INFO *block_info)
{
DBUG_ENTER("unlink_deleted_block");
if (block_info->filepos == info->s->state.dellink)
{
/* First deleted block; We can just use this ! */
info->s->state.dellink=block_info->next_filepos;
}
else
{
MI_BLOCK_INFO tmp;
tmp.second_read=0;
/* Unlink block from the previous block */
if (!(_mi_get_block_info(&tmp,info->dfile,block_info->prev_filepos)
& BLOCK_DELETED))
DBUG_RETURN(1); /* Something is wrong */
mi_sizestore(tmp.header+4,block_info->next_filepos);
if (info->s->file_write(info, tmp.header+4,8,
block_info->prev_filepos+4, MYF(MY_NABP)))
DBUG_RETURN(1);
/* Unlink block from next block */
if (block_info->next_filepos != HA_OFFSET_ERROR)
{
if (!(_mi_get_block_info(&tmp,info->dfile,block_info->next_filepos)
& BLOCK_DELETED))
DBUG_RETURN(1); /* Something is wrong */
mi_sizestore(tmp.header+12,block_info->prev_filepos);
if (info->s->file_write(info, tmp.header+12,8,
block_info->next_filepos+12,
MYF(MY_NABP)))
DBUG_RETURN(1);
}
}
/* We now have one less deleted block */
info->state->del--;
info->state->empty-= block_info->block_len;
info->s->state.split--;
/*
If this was a block that we where accessing through table scan
(mi_rrnd() or mi_scan(), then ensure that we skip over this block
when doing next mi_rrnd() or mi_scan().
*/
if (info->nextpos == block_info->filepos)
info->nextpos+=block_info->block_len;
DBUG_RETURN(0);
} | O3 | c | unlink_deleted_block:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movq 0x38(%rsi), %rcx
movq (%rdi), %rax
cmpq 0x58(%rax), %rcx
jne 0x786b3
movq 0x40(%r14), %rcx
movq %rcx, 0x58(%rax)
movq 0x8(%rbx), %rax
decq 0x8(%rax)
movq 0x28(%r14), %rax
movq 0x8(%rbx), %rcx
subq %rax, 0x10(%rcx)
movq (%rbx), %rax
decq 0x50(%rax)
movq 0x178(%rbx), %rax
cmpq 0x38(%r14), %rax
jne 0x786af
addq 0x28(%r14), %rax
movq %rax, 0x178(%rbx)
xorl %eax, %eax
jmp 0x78705
leaq -0x70(%rbp), %rdi
movl $0x0, 0x50(%rdi)
movl 0x1c0(%rbx), %esi
movq 0x48(%r14), %rdx
callq 0x78273
testb $0x4, %al
je 0x78703
movq 0x40(%r14), %rax
leaq -0x6c(%rbp), %rsi
bswapq %rax
movq %rax, (%rsi)
movq (%rbx), %rax
movq 0x48(%r14), %rcx
addq $0x4, %rcx
movl $0x8, %edx
movl $0x4, %r8d
movq %rbx, %rdi
callq *0x2e8(%rax)
testq %rax, %rax
je 0x7871d
movb $0x1, %al
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x78775
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x40(%r14), %rdx
cmpq $-0x1, %rdx
je 0x7867c
movl 0x1c0(%rbx), %esi
leaq -0x70(%rbp), %rdi
callq 0x78273
testb $0x4, %al
je 0x78703
movq 0x48(%r14), %rax
leaq -0x64(%rbp), %rsi
bswapq %rax
movq %rax, (%rsi)
movq (%rbx), %rax
movq 0x40(%r14), %rcx
addq $0xc, %rcx
movl $0x8, %edx
movl $0x4, %r8d
movq %rbx, %rdi
callq *0x2e8(%rax)
testq %rax, %rax
jne 0x78703
jmp 0x7867c
callq 0x29250
| unlink_deleted_block_0:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 60h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
mov rcx, [rsi+38h]
mov rax, [rdi]
cmp rcx, [rax+58h]
jnz short loc_786B3
mov rcx, [r14+40h]
mov [rax+58h], rcx
loc_7867C:
mov rax, [rbx+8]
dec qword ptr [rax+8]
mov rax, [r14+28h]
mov rcx, [rbx+8]
sub [rcx+10h], rax
mov rax, [rbx]
dec qword ptr [rax+50h]
mov rax, [rbx+178h]
cmp rax, [r14+38h]
jnz short loc_786AF
add rax, [r14+28h]
mov [rbx+178h], rax
loc_786AF:
xor eax, eax
jmp short loc_78705
loc_786B3:
lea rdi, [rbp+var_70]
mov dword ptr [rdi+50h], 0
mov esi, [rbx+1C0h]
mov rdx, [r14+48h]
call _mi_get_block_info
test al, 4
jz short loc_78703
mov rax, [r14+40h]
lea rsi, [rbp+var_6C]
bswap rax
mov [rsi], rax
mov rax, [rbx]
mov rcx, [r14+48h]
add rcx, 4
mov edx, 8
mov r8d, 4
mov rdi, rbx
call qword ptr [rax+2E8h]
test rax, rax
jz short loc_7871D
loc_78703:
mov al, 1
loc_78705:
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_78775
add rsp, 60h
pop rbx
pop r14
pop rbp
retn
loc_7871D:
mov rdx, [r14+40h]
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz loc_7867C
mov esi, [rbx+1C0h]
lea rdi, [rbp+var_70]
call _mi_get_block_info
test al, 4
jz short loc_78703
mov rax, [r14+48h]
lea rsi, [rbp+var_64]
bswap rax
mov [rsi], rax
mov rax, [rbx]
mov rcx, [r14+40h]
add rcx, 0Ch
mov edx, 8
mov r8d, 4
mov rdi, rbx
call qword ptr [rax+2E8h]
test rax, rax
jnz short loc_78703
jmp loc_7867C
loc_78775:
call ___stack_chk_fail
| char unlink_deleted_block_0(_QWORD *a1, _QWORD *a2)
{
long long v2; // rax
long long v4; // rdx
_BYTE v5[4]; // [rsp+0h] [rbp-70h] BYREF
unsigned long long v6; // [rsp+4h] [rbp-6Ch] BYREF
unsigned long long v7[8]; // [rsp+Ch] [rbp-64h] BYREF
int v8; // [rsp+50h] [rbp-20h]
unsigned long long v9; // [rsp+58h] [rbp-18h]
v9 = __readfsqword(0x28u);
if ( a2[7] == *(_QWORD *)(*a1 + 88LL) )
{
*(_QWORD *)(*a1 + 88LL) = a2[8];
}
else
{
v8 = 0;
if ( (mi_get_block_info((long long)v5, *((unsigned int *)a1 + 112), a2[9]) & 4) == 0 )
return 1;
v6 = _byteswap_uint64(a2[8]);
if ( (*(long long ( **)(_QWORD *, unsigned long long *, long long, long long, long long))(*a1 + 744LL))(
a1,
&v6,
8LL,
a2[9] + 4LL,
4LL) )
{
return 1;
}
v4 = a2[8];
if ( v4 != -1 )
{
if ( (mi_get_block_info((long long)v5, *((unsigned int *)a1 + 112), v4) & 4) == 0 )
return 1;
v7[0] = _byteswap_uint64(a2[9]);
if ( (*(long long ( **)(_QWORD *, unsigned long long *, long long, long long, long long))(*a1 + 744LL))(
a1,
v7,
8LL,
a2[8] + 12LL,
4LL) )
{
return 1;
}
}
}
--*(_QWORD *)(a1[1] + 8LL);
*(_QWORD *)(a1[1] + 16LL) -= a2[5];
--*(_QWORD *)(*a1 + 80LL);
v2 = a1[47];
if ( v2 == a2[7] )
a1[47] = a2[5] + v2;
return 0;
}
| unlink_deleted_block:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RSI + 0x38]
MOV RAX,qword ptr [RDI]
CMP RCX,qword ptr [RAX + 0x58]
JNZ 0x001786b3
MOV RCX,qword ptr [R14 + 0x40]
MOV qword ptr [RAX + 0x58],RCX
LAB_0017867c:
MOV RAX,qword ptr [RBX + 0x8]
DEC qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14 + 0x28]
MOV RCX,qword ptr [RBX + 0x8]
SUB qword ptr [RCX + 0x10],RAX
MOV RAX,qword ptr [RBX]
DEC qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBX + 0x178]
CMP RAX,qword ptr [R14 + 0x38]
JNZ 0x001786af
ADD RAX,qword ptr [R14 + 0x28]
MOV qword ptr [RBX + 0x178],RAX
LAB_001786af:
XOR EAX,EAX
JMP 0x00178705
LAB_001786b3:
LEA RDI,[RBP + -0x70]
MOV dword ptr [RDI + 0x50],0x0
MOV ESI,dword ptr [RBX + 0x1c0]
MOV RDX,qword ptr [R14 + 0x48]
CALL 0x00178273
TEST AL,0x4
JZ 0x00178703
MOV RAX,qword ptr [R14 + 0x40]
LEA RSI,[RBP + -0x6c]
BSWAP RAX
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [R14 + 0x48]
ADD RCX,0x4
MOV EDX,0x8
MOV R8D,0x4
MOV RDI,RBX
CALL qword ptr [RAX + 0x2e8]
TEST RAX,RAX
JZ 0x0017871d
LAB_00178703:
MOV AL,0x1
LAB_00178705:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x00178775
ADD RSP,0x60
POP RBX
POP R14
POP RBP
RET
LAB_0017871d:
MOV RDX,qword ptr [R14 + 0x40]
CMP RDX,-0x1
JZ 0x0017867c
MOV ESI,dword ptr [RBX + 0x1c0]
LEA RDI,[RBP + -0x70]
CALL 0x00178273
TEST AL,0x4
JZ 0x00178703
MOV RAX,qword ptr [R14 + 0x48]
LEA RSI,[RBP + -0x64]
BSWAP RAX
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [R14 + 0x40]
ADD RCX,0xc
MOV EDX,0x8
MOV R8D,0x4
MOV RDI,RBX
CALL qword ptr [RAX + 0x2e8]
TEST RAX,RAX
JNZ 0x00178703
JMP 0x0017867c
LAB_00178775:
CALL 0x00129250
|
int8 unlink_deleted_block(long *param_1,long param_2)
{
ulong uVar1;
long lVar2;
int8 uVar3;
long in_FS_OFFSET;
int1 local_78 [4];
ulong local_74;
ulong local_6c [8];
int4 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (*(long *)(param_2 + 0x38) == *(long *)(*param_1 + 0x58)) {
*(int8 *)(*param_1 + 0x58) = *(int8 *)(param_2 + 0x40);
goto LAB_0017867c;
}
local_28 = 0;
uVar1 = _mi_get_block_info(local_78,(int)param_1[0x38],*(int8 *)(param_2 + 0x48));
if ((uVar1 & 4) != 0) {
uVar1 = *(ulong *)(param_2 + 0x40);
local_74 = uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 | (uVar1 & 0xff0000000000) >> 0x18
| (uVar1 & 0xff00000000) >> 8 | (uVar1 & 0xff000000) << 8 |
(uVar1 & 0xff0000) << 0x18 | (uVar1 & 0xff00) << 0x28 | uVar1 << 0x38;
lVar2 = (**(code **)(*param_1 + 0x2e8))(param_1,&local_74,8,*(long *)(param_2 + 0x48) + 4,4);
if (lVar2 == 0) {
if (*(long *)(param_2 + 0x40) == -1) {
LAB_0017867c:
*(long *)(param_1[1] + 8) = *(long *)(param_1[1] + 8) + -1;
*(long *)(param_1[1] + 0x10) = *(long *)(param_1[1] + 0x10) - *(long *)(param_2 + 0x28);
*(long *)(*param_1 + 0x50) = *(long *)(*param_1 + 0x50) + -1;
if (param_1[0x2f] == *(long *)(param_2 + 0x38)) {
param_1[0x2f] = param_1[0x2f] + *(long *)(param_2 + 0x28);
}
uVar3 = 0;
goto LAB_00178705;
}
uVar1 = _mi_get_block_info(local_78,(int)param_1[0x38]);
if ((uVar1 & 4) != 0) {
uVar1 = *(ulong *)(param_2 + 0x48);
local_6c[0] = uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 |
(uVar1 & 0xff0000000000) >> 0x18 | (uVar1 & 0xff00000000) >> 8 |
(uVar1 & 0xff000000) << 8 | (uVar1 & 0xff0000) << 0x18 |
(uVar1 & 0xff00) << 0x28 | uVar1 << 0x38;
lVar2 = (**(code **)(*param_1 + 0x2e8))
(param_1,local_6c,8,*(long *)(param_2 + 0x40) + 0xc,4);
if (lVar2 == 0) goto LAB_0017867c;
}
}
}
uVar3 = 1;
LAB_00178705:
if (*(long *)(in_FS_OFFSET + 0x28) != local_20) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
}
| |
51,227 | lre_compute_stack_size | bluesky950520[P]quickjs/libregexp.c | static int lre_compute_stack_size(const uint8_t *bc_buf, int bc_buf_len)
{
int stack_size, stack_size_max, pos, opcode, len;
uint32_t val;
stack_size = 0;
stack_size_max = 0;
bc_buf += RE_HEADER_LEN;
bc_buf_len -= RE_HEADER_LEN;
pos = 0;
while (pos < bc_buf_len) {
opcode = bc_buf[pos];
len = reopcode_info[opcode].size;
assert(opcode < REOP_COUNT);
assert((pos + len) <= bc_buf_len);
switch(opcode) {
case REOP_push_i32:
case REOP_push_char_pos:
stack_size++;
if (stack_size > stack_size_max) {
if (stack_size > STACK_SIZE_MAX)
return -1;
stack_size_max = stack_size;
}
break;
case REOP_drop:
case REOP_check_advance:
assert(stack_size > 0);
stack_size--;
break;
case REOP_range:
val = get_u16(bc_buf + pos + 1);
len += val * 4;
break;
case REOP_range32:
val = get_u16(bc_buf + pos + 1);
len += val * 8;
break;
}
pos += len;
}
return stack_size_max;
} | O0 | c | lre_compute_stack_size:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movl 0x24(%rsp), %eax
subl $0x8, %eax
movl %eax, 0x24(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0xfc994
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x14(%rsp)
movslq 0x14(%rsp), %rax
leaq 0x14826(%rip), %rcx # 0x1110e0
movzbl (%rax,%rcx), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
addl $-0x10, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0xb, %eax
ja 0xfc983
movq (%rsp), %rax
leaq 0x142d1(%rip), %rcx # 0x110bb4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jle 0xfc920
cmpl $0xff, 0x20(%rsp)
jle 0xfc918
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xfc99c
movl 0x20(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0xfc983
movl 0x20(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xfc983
movq 0x28(%rsp), %rdi
movslq 0x18(%rsp), %rax
addq %rax, %rdi
addq $0x1, %rdi
callq 0xfec10
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
shll $0x2, %eax
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0xfc983
movq 0x28(%rsp), %rdi
movslq 0x18(%rsp), %rax
addq %rax, %rdi
addq $0x1, %rdi
callq 0xfec10
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
shll $0x3, %eax
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0xfc88e
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| lre_compute_stack_size:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_14], esi
mov [rsp+38h+var_18], 0
mov [rsp+38h+var_1C], 0
mov rax, [rsp+38h+var_10]
add rax, 8
mov [rsp+38h+var_10], rax
mov eax, [rsp+38h+var_14]
sub eax, 8
mov [rsp+38h+var_14], eax
mov [rsp+38h+var_20], 0
loc_FC88E:
mov eax, [rsp+38h+var_20]
cmp eax, [rsp+38h+var_14]
jge loc_FC994
mov rax, [rsp+38h+var_10]
movsxd rcx, [rsp+38h+var_20]
movzx eax, byte ptr [rax+rcx]
mov [rsp+38h+var_24], eax
movsxd rax, [rsp+38h+var_24]
lea rcx, reopcode_info
movzx eax, byte ptr [rax+rcx]
mov [rsp+38h+var_28], eax
mov eax, [rsp+38h+var_24]
add eax, 0FFFFFFF0h; switch 12 cases
mov ecx, eax
mov [rsp+38h+var_38], rcx
sub eax, 0Bh
ja def_FC8EA; jumptable 00000000000FC8EA default case, cases 18-21,24,25
mov rax, [rsp+38h+var_38]
lea rcx, jpt_FC8EA
movsxd rax, ds:(jpt_FC8EA - 110BB4h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_FC8EC:
mov eax, [rsp+38h+var_18]; jumptable 00000000000FC8EA cases 16,26
add eax, 1
mov [rsp+38h+var_18], eax
mov eax, [rsp+38h+var_18]
cmp eax, [rsp+38h+var_1C]
jle short loc_FC920
cmp [rsp+38h+var_18], 0FFh
jle short loc_FC918
mov [rsp+38h+var_4], 0FFFFFFFFh
jmp loc_FC99C
loc_FC918:
mov eax, [rsp+38h+var_18]
mov [rsp+38h+var_1C], eax
loc_FC920:
jmp short def_FC8EA; jumptable 00000000000FC8EA default case, cases 18-21,24,25
loc_FC922:
mov eax, [rsp+38h+var_18]; jumptable 00000000000FC8EA cases 17,27
add eax, 0FFFFFFFFh
mov [rsp+38h+var_18], eax
jmp short def_FC8EA; jumptable 00000000000FC8EA default case, cases 18-21,24,25
loc_FC92F:
mov rdi, [rsp+38h+var_10]; jumptable 00000000000FC8EA case 22
movsxd rax, [rsp+38h+var_20]
add rdi, rax
add rdi, 1
call get_u16_0
mov [rsp+38h+var_2C], eax
mov eax, [rsp+38h+var_2C]
shl eax, 2
add eax, [rsp+38h+var_28]
mov [rsp+38h+var_28], eax
jmp short def_FC8EA; jumptable 00000000000FC8EA default case, cases 18-21,24,25
loc_FC95A:
mov rdi, [rsp+38h+var_10]; jumptable 00000000000FC8EA case 23
movsxd rax, [rsp+38h+var_20]
add rdi, rax
add rdi, 1
call get_u16_0
mov [rsp+38h+var_2C], eax
mov eax, [rsp+38h+var_2C]
shl eax, 3
add eax, [rsp+38h+var_28]
mov [rsp+38h+var_28], eax
def_FC8EA:
mov eax, [rsp+38h+var_28]; jumptable 00000000000FC8EA default case, cases 18-21,24,25
add eax, [rsp+38h+var_20]
mov [rsp+38h+var_20], eax
jmp loc_FC88E
loc_FC994:
mov eax, [rsp+38h+var_1C]
mov [rsp+38h+var_4], eax
loc_FC99C:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| long long lre_compute_stack_size(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-28h]
int v4; // [rsp+18h] [rbp-20h]
int v5; // [rsp+1Ch] [rbp-1Ch]
int v6; // [rsp+20h] [rbp-18h]
long long v7; // [rsp+28h] [rbp-10h]
v6 = 0;
v5 = 0;
v7 = a1 + 8;
v4 = 0;
while ( v4 < a2 - 8 )
{
v3 = reopcode_info[*(unsigned __int8 *)(v7 + v4)];
switch ( *(_BYTE *)(v7 + v4) )
{
case 0x10:
case 0x1A:
if ( ++v6 <= v5 )
goto LABEL_12;
if ( v6 <= 255 )
{
v5 = v6;
goto LABEL_12;
}
return (unsigned int)-1;
case 0x11:
case 0x1B:
--v6;
goto LABEL_12;
case 0x16:
v3 += 4 * get_u16_0(v4 + v7 + 1);
goto LABEL_12;
case 0x17:
v3 += 8 * get_u16_0(v4 + v7 + 1);
goto LABEL_12;
default:
LABEL_12:
v4 += v3;
break;
}
}
return (unsigned int)v5;
}
| lre_compute_stack_size:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV dword ptr [RSP + 0x24],ESI
MOV dword ptr [RSP + 0x20],0x0
MOV dword ptr [RSP + 0x1c],0x0
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,0x8
MOV qword ptr [RSP + 0x28],RAX
MOV EAX,dword ptr [RSP + 0x24]
SUB EAX,0x8
MOV dword ptr [RSP + 0x24],EAX
MOV dword ptr [RSP + 0x18],0x0
LAB_001fc88e:
MOV EAX,dword ptr [RSP + 0x18]
CMP EAX,dword ptr [RSP + 0x24]
JGE 0x001fc994
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0x18]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RSP + 0x14],EAX
MOVSXD RAX,dword ptr [RSP + 0x14]
LEA RCX,[0x2110e0]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RSP + 0x10],EAX
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,-0x10
MOV ECX,EAX
MOV qword ptr [RSP],RCX
SUB EAX,0xb
JA 0x001fc983
MOV RAX,qword ptr [RSP]
LEA RCX,[0x210bb4]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_10:
MOV EAX,dword ptr [RSP + 0x20]
ADD EAX,0x1
MOV dword ptr [RSP + 0x20],EAX
MOV EAX,dword ptr [RSP + 0x20]
CMP EAX,dword ptr [RSP + 0x1c]
JLE 0x001fc920
CMP dword ptr [RSP + 0x20],0xff
JLE 0x001fc918
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x001fc99c
LAB_001fc918:
MOV EAX,dword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x1c],EAX
LAB_001fc920:
JMP 0x001fc983
caseD_11:
MOV EAX,dword ptr [RSP + 0x20]
ADD EAX,-0x1
MOV dword ptr [RSP + 0x20],EAX
JMP 0x001fc983
caseD_16:
MOV RDI,qword ptr [RSP + 0x28]
MOVSXD RAX,dword ptr [RSP + 0x18]
ADD RDI,RAX
ADD RDI,0x1
CALL 0x001fec10
MOV dword ptr [RSP + 0xc],EAX
MOV EAX,dword ptr [RSP + 0xc]
SHL EAX,0x2
ADD EAX,dword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x10],EAX
JMP 0x001fc983
caseD_17:
MOV RDI,qword ptr [RSP + 0x28]
MOVSXD RAX,dword ptr [RSP + 0x18]
ADD RDI,RAX
ADD RDI,0x1
CALL 0x001fec10
MOV dword ptr [RSP + 0xc],EAX
MOV EAX,dword ptr [RSP + 0xc]
SHL EAX,0x3
ADD EAX,dword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x10],EAX
caseD_12:
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,dword ptr [RSP + 0x18]
MOV dword ptr [RSP + 0x18],EAX
JMP 0x001fc88e
LAB_001fc994:
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x34],EAX
LAB_001fc99c:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int lre_compute_stack_size(long param_1,int param_2)
{
int iVar1;
uint local_28;
int local_20;
int local_1c;
int local_18;
local_18 = 0;
local_1c = 0;
param_1 = param_1 + 8;
local_20 = 0;
do {
if (param_2 + -8 <= local_20) {
return local_1c;
}
local_28 = (uint)(byte)reopcode_info[(int)(uint)*(byte *)(param_1 + local_20)];
switch((uint)*(byte *)(param_1 + local_20)) {
case 0x10:
case 0x1a:
local_18 = local_18 + 1;
if ((local_1c < local_18) && (local_1c = local_18, 0xff < local_18)) {
return -1;
}
break;
case 0x11:
case 0x1b:
local_18 = local_18 + -1;
break;
case 0x16:
iVar1 = get_u16(param_1 + local_20 + 1);
local_28 = iVar1 * 4 + local_28;
break;
case 0x17:
iVar1 = get_u16(param_1 + local_20 + 1);
local_28 = iVar1 * 8 + local_28;
}
local_20 = local_28 + local_20;
} while( true );
}
| |
51,228 | get_charset_number | eloqsql/mysys/charset.c | uint get_charset_number(const char *charset_name, uint cs_flags, myf flags)
{
uint id;
const char *new_charset_name= flags & MY_UTF8_IS_UTF8MB3 ? "utf8mb3" :
"utf8mb4";
my_pthread_once(&charsets_initialized, init_available_charsets);
if ((id= get_charset_number_internal(charset_name, cs_flags)))
return id;
if ((charset_name= !my_strcasecmp(&my_charset_latin1, charset_name, "utf8") ?
new_charset_name : NULL))
return get_charset_number_internal(charset_name, cs_flags);
return 0;
} | O3 | c | get_charset_number:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
leaq 0xb74f25(%rip), %rdi # 0xc07670
leaq -0x20b(%rip), %rsi # 0x92547
callq 0x29220
movq %r15, %rdi
movl %ebx, %esi
callq 0x927b8
testl %eax, %eax
jne 0x92788
leaq 0x3197b4(%rip), %rdi # 0x3abf20
movq 0xc0(%rdi), %rax
leaq 0x49707(%rip), %rdx # 0xdbe81
movq %r15, %rsi
callq *0x40(%rax)
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x92793
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
btl $0xa, %r14d
leaq 0x496da(%rip), %rax # 0xdbe79
leaq 0x496cb(%rip), %rdi # 0xdbe71
cmovaeq %rax, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x927b8
| get_charset_number:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rdx
mov ebx, esi
mov r15, rdi
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, r15
mov esi, ebx
call get_charset_number_internal
test eax, eax
jnz short loc_92788
lea rdi, my_charset_latin1
mov rax, [rdi+0C0h]
lea rdx, aUtf8; "utf8"
mov rsi, r15
call qword ptr [rax+40h]
mov ecx, eax
xor eax, eax
test ecx, ecx
jz short loc_92793
loc_92788:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_92793:
bt r14d, 0Ah
lea rax, aUtf8mb4; "utf8mb4"
lea rdi, aUtf8mb3; "utf8mb3"
cmovnb rdi, rax
mov esi, ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp short $+2
| long long get_charset_number(long long a1, unsigned int a2, __int16 a3)
{
long long result; // rax
int v5; // ecx
const char *v6; // rdi
pthread_once(&charsets_initialized, init_available_charsets);
result = get_charset_number_internal(a1, a2);
if ( !(_DWORD)result )
{
v5 = (*(long long ( **)(void *, long long, const char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
a1,
"utf8");
result = 0LL;
if ( !v5 )
{
v6 = "utf8mb3";
if ( (a3 & 0x400) == 0 )
v6 = "utf8mb4";
return get_charset_number_internal(v6, a2);
}
}
return result;
}
| get_charset_number:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV EBX,ESI
MOV R15,RDI
LEA RDI,[0xd07670]
LEA RSI,[0x192547]
CALL 0x00129220
MOV RDI,R15
MOV ESI,EBX
CALL 0x001927b8
TEST EAX,EAX
JNZ 0x00192788
LEA RDI,[0x4abf20]
MOV RAX,qword ptr [RDI + 0xc0]
LEA RDX,[0x1dbe81]
MOV RSI,R15
CALL qword ptr [RAX + 0x40]
MOV ECX,EAX
XOR EAX,EAX
TEST ECX,ECX
JZ 0x00192793
LAB_00192788:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00192793:
BT R14D,0xa
LEA RAX,[0x1dbe79]
LEA RDI,[0x1dbe71]
CMOVNC RDI,RAX
MOV ESI,EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001927b8
|
int8 get_charset_number(int8 param_1,int4 param_2,uint param_3)
{
int iVar1;
int8 uVar2;
char *pcVar3;
pthread_once(&charsets_initialized,init_available_charsets);
uVar2 = get_charset_number_internal(param_1,param_2);
if ((int)uVar2 == 0) {
iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_004abfe0 + 0x40))
(&my_charset_latin1,param_1,&DAT_001dbe81);
uVar2 = 0;
if (iVar1 == 0) {
pcVar3 = "utf8mb3";
if ((param_3 >> 10 & 1) == 0) {
pcVar3 = "utf8mb4";
}
uVar2 = get_charset_number_internal(pcVar3,param_2);
return uVar2;
}
}
return uVar2;
}
| |
51,229 | minja::Value::size() const | monkey531[P]llama/common/./minja.hpp | size_t size() const {
if (is_object()) return object_->size();
if (is_array()) return array_->size();
if (is_string()) return primitive_.get<std::string>().length();
throw std::runtime_error("Value is not an array or object: " + dump());
} | O0 | cpp | minja::Value::size() const:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xa5180
testb $0x1, %al
jne 0xd3977
jmp 0xd399a
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0xa1ad0
movq %rax, %rdi
callq 0xc9e90
movq %rax, 0x90(%rsp)
jmp 0xd3adc
movq 0x10(%rsp), %rdi
callq 0xa4990
testb $0x1, %al
jne 0xd39aa
jmp 0xd39cd
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0xa19f0
movq %rax, %rdi
callq 0xa1a00
movq %rax, 0x90(%rsp)
jmp 0xd3adc
movq 0x10(%rsp), %rdi
callq 0xa1f30
testb $0x1, %al
jne 0xd39dd
jmp 0xd3a11
movq 0x10(%rsp), %rsi
addq $0x40, %rsi
leaq 0x68(%rsp), %rdi
callq 0xa4e20
leaq 0x68(%rsp), %rdi
callq 0x50830
movq %rax, 0x90(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x510c0
jmp 0xd3adc
movb $0x1, 0x1b(%rsp)
movl $0x10, %edi
callq 0x50540
movq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x9feb0
jmp 0xd3a3d
leaq 0xfdd4e(%rip), %rsi # 0x1d1792
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x7a6e0
jmp 0xd3a55
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x50390
jmp 0xd3a66
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x180539(%rip), %rsi # 0x253fb0
movq 0x1804fa(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0xd3af6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0xd3ac7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0xd3abd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x510c0
leaq 0x28(%rsp), %rdi
callq 0x510c0
testb $0x1, 0x1b(%rsp)
jne 0xd3ad0
jmp 0xd3ada
movq 0x8(%rsp), %rdi
callq 0x50c40
jmp 0xd3aec
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x50940
nopw %cs:(%rax,%rax)
| _ZNK5minja5Value4sizeEv:
sub rsp, 98h
mov [rsp+98h+var_10], rdi
mov rdi, [rsp+98h+var_10]; this
mov [rsp+98h+var_88], rdi
call _ZNK5minja5Value9is_objectEv; minja::Value::is_object(void)
test al, 1
jnz short loc_D3977
jmp short loc_D399A
loc_D3977:
mov rdi, [rsp+98h+var_88]
add rdi, 20h ; ' '
call _ZNKSt19__shared_ptr_accessIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
call _ZNKSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE4sizeEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::size(void)
mov [rsp+98h+var_8], rax
jmp loc_D3ADC
loc_D399A:
mov rdi, [rsp+98h+var_88]; this
call _ZNK5minja5Value8is_arrayEv; minja::Value::is_array(void)
test al, 1
jnz short loc_D39AA
jmp short loc_D39CD
loc_D39AA:
mov rdi, [rsp+98h+var_88]
add rdi, 10h
call _ZNKSt19__shared_ptr_accessISt6vectorIN5minja5ValueESaIS2_EELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
call _ZNKSt6vectorIN5minja5ValueESaIS1_EE4sizeEv; std::vector<minja::Value>::size(void)
mov [rsp+98h+var_8], rax
jmp loc_D3ADC
loc_D39CD:
mov rdi, [rsp+98h+var_88]; this
call _ZNK5minja5Value9is_stringEv; minja::Value::is_string(void)
test al, 1
jnz short loc_D39DD
jmp short loc_D3A11
loc_D39DD:
mov rsi, [rsp+98h+var_88]
add rsi, 40h ; '@'; __int64
lea rdi, [rsp+98h+var_30]; void *
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE3getIS9_S9_EEDTcldtclL_ZSt7declvalIRKSD_EDTcl9__declvalIT_ELi0EEEvEE8get_implIT0_EtlNS0_6detail12priority_tagILj4EEEEEEv
lea rdi, [rsp+98h+var_30]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
mov [rsp+98h+var_8], rax
lea rdi, [rsp+98h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_D3ADC
loc_D3A11:
mov [rsp+98h+var_7D], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rsi, [rsp+98h+var_88]
mov [rsp+98h+var_90], rax
lea rdi, [rsp+98h+var_70]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_D3A3D:
lea rsi, aValueIsNotAnAr_0; "Value is not an array or object: "
lea rdi, [rsp+98h+var_50]
lea rdx, [rsp+98h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_D3A55:
mov rdi, [rsp+98h+var_90]
lea rsi, [rsp+98h+var_50]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_D3A66:
mov rdi, [rsp+98h+var_90]; void *
mov [rsp+98h+var_7D], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp short loc_D3AF6
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
jmp short loc_D3AC7
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
jmp short loc_D3ABD
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_D3ABD:
lea rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_D3AC7:
test [rsp+arg_13], 1
jnz short loc_D3AD0
jmp short loc_D3ADA
loc_D3AD0:
mov rdi, [rsp+arg_0]; void *
call ___cxa_free_exception
loc_D3ADA:
jmp short loc_D3AEC
loc_D3ADC:
mov rax, [rsp+98h+var_8]
add rsp, 98h
retn
loc_D3AEC:
mov rdi, [rsp+arg_18]
call __Unwind_Resume
loc_D3AF6:
nop word ptr [rax+rax+00000000h]
| long long minja::Value::size(minja::Value *this)
{
_QWORD *v1; // rax
_QWORD *v2; // rax
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
void *exception; // [rsp+8h] [rbp-90h]
_BYTE v9[32]; // [rsp+28h] [rbp-70h] BYREF
_BYTE v10[32]; // [rsp+48h] [rbp-50h] BYREF
_BYTE v11[32]; // [rsp+68h] [rbp-30h] BYREF
minja::Value *v12; // [rsp+88h] [rbp-10h]
long long v13; // [rsp+90h] [rbp-8h]
v12 = this;
if ( minja::Value::is_object(this) )
{
v1 = (_QWORD *)std::__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((long long)this + 32);
return std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::size(v1);
}
else if ( minja::Value::is_array(this) )
{
v2 = (_QWORD *)std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((long long)this + 16);
return std::vector<minja::Value>::size(v2);
}
else
{
if ( !minja::Value::is_string(this) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v9, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v10, (long long)"Value is not an array or object: ", (long long)v9);
std::runtime_error::runtime_error(exception, v10);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get<std::string,std::string>(
v11,
(long long)this + 64,
v3,
v4,
v5,
v6);
v13 = std::string::length(v11);
std::string::~string(v11);
}
return v13;
}
| size:
SUB RSP,0x98
MOV qword ptr [RSP + 0x88],RDI
MOV RDI,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x001a5180
TEST AL,0x1
JNZ 0x001d3977
JMP 0x001d399a
LAB_001d3977:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x20
CALL 0x001a1ad0
MOV RDI,RAX
CALL 0x001c9e90
MOV qword ptr [RSP + 0x90],RAX
JMP 0x001d3adc
LAB_001d399a:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001a4990
TEST AL,0x1
JNZ 0x001d39aa
JMP 0x001d39cd
LAB_001d39aa:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x10
CALL 0x001a19f0
MOV RDI,RAX
CALL 0x001a1a00
MOV qword ptr [RSP + 0x90],RAX
JMP 0x001d3adc
LAB_001d39cd:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001a1f30
TEST AL,0x1
JNZ 0x001d39dd
JMP 0x001d3a11
LAB_001d39dd:
MOV RSI,qword ptr [RSP + 0x10]
ADD RSI,0x40
LEA RDI,[RSP + 0x68]
CALL 0x001a4e20
LEA RDI,[RSP + 0x68]
CALL 0x00150830
MOV qword ptr [RSP + 0x90],RAX
LEA RDI,[RSP + 0x68]
CALL 0x001510c0
JMP 0x001d3adc
LAB_001d3a11:
MOV byte ptr [RSP + 0x1b],0x1
MOV EDI,0x10
CALL 0x00150540
MOV RSI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
LAB_001d3a2a:
LEA RDI,[RSP + 0x28]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0019feb0
JMP 0x001d3a3d
LAB_001d3a3d:
LEA RSI,[0x2d1792]
LEA RDI,[RSP + 0x48]
LEA RDX,[RSP + 0x28]
CALL 0x0017a6e0
JMP 0x001d3a55
LAB_001d3a55:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x48]
CALL 0x00150390
JMP 0x001d3a66
LAB_001d3a66:
MOV RDI,qword ptr [RSP + 0x8]
MOV byte ptr [RSP + 0x1b],0x0
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
LAB_001d3adc:
MOV RAX,qword ptr [RSP + 0x90]
ADD RSP,0x98
RET
|
/* minja::Value::size() const */
int8 __thiscall minja::Value::size(Value *this)
{
ulong uVar1;
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*this_00;
vector<minja::Value,std::allocator<minja::Value>> *this_01;
runtime_error *this_02;
int1 local_70 [32];
string local_50 [32];
string local_30 [32];
Value *local_10;
int8 local_8;
local_10 = this;
uVar1 = is_object(this);
if ((uVar1 & 1) == 0) {
uVar1 = is_array(this);
if ((uVar1 & 1) == 0) {
uVar1 = is_string(this);
if ((uVar1 & 1) == 0) {
this_02 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001d3a2a to 001d3a3a has its CatchHandler @ 001d3a85 */
dump_abi_cxx11_((int)local_70,SUB81(this,0));
/* try { // try from 001d3a3d to 001d3a52 has its CatchHandler @ 001d3a95 */
std::operator+((char *)local_50,(string *)"Value is not an array or object: ");
/* try { // try from 001d3a55 to 001d3a82 has its CatchHandler @ 001d3aa5 */
std::runtime_error::runtime_error(this_02,local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this_02,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get<std::__cxx11::string,std::__cxx11::string>();
local_8 = std::__cxx11::string::length();
std::__cxx11::string::~string(local_30);
}
else {
this_01 = (vector<minja::Value,std::allocator<minja::Value>> *)
std::
__shared_ptr_access<std::vector<minja::Value,std::allocator<minja::Value>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<std::vector<minja::Value,std::allocator<minja::Value>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x10));
local_8 = std::vector<minja::Value,std::allocator<minja::Value>>::size(this_01);
}
}
else {
this_00 = (vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)std::
__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x20));
local_8 = std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::size(this_00);
}
return local_8;
}
| |
51,230 | ma_set_dynamic | eloqsql/libmariadb/libmariadb/ma_array.c | my_bool ma_set_dynamic(DYNAMIC_ARRAY *array, void * element, uint idx)
{
if (idx >= array->elements)
{
if (idx >= array->max_element)
{
uint size;
char *new_ptr;
size=(idx+array->alloc_increment)/array->alloc_increment;
size*= array->alloc_increment;
if (!(new_ptr=(char*) realloc(array->buffer,size*
array->size_of_element)))
return TRUE;
array->buffer=new_ptr;
array->max_element=size;
}
memset((array->buffer+array->elements*array->size_of_element), 0,
(idx - array->elements)*array->size_of_element);
array->elements=idx+1;
}
memcpy(array->buffer+(idx * array->size_of_element),element,
(size_t) array->size_of_element);
return FALSE;
} | O0 | c | ma_set_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x748eb
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x748a6
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x10(%rcx)
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
imull -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x380c0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x74891
movb $0x1, -0x1(%rbp)
jmp 0x74918
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x38300
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %edx
callq 0x380b0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_set_dynamic:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp eax, [rcx+8]
jb loc_748EB
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jb short loc_748A6
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
xor edx, edx
div dword ptr [rcx+10h]
mov [rbp+var_20], eax
mov rax, [rbp+var_10]
mov eax, [rax+10h]
imul eax, [rbp+var_20]
mov [rbp+var_20], eax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov eax, [rbp+var_20]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov esi, eax
call _realloc
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_74891
mov [rbp+var_1], 1
jmp loc_74918
loc_74891:
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax], rcx
mov ecx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+0Ch], ecx
loc_748A6:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
add rdi, rax
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
sub eax, [rcx+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
mov ecx, [rbp+var_1C]
add ecx, 1
mov rax, [rbp+var_10]
mov [rax+8], ecx
loc_748EB:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
add rdi, rax
mov rsi, [rbp+var_18]
mov rax, [rbp+var_10]
mov eax, [rax+14h]
mov edx, eax
call _memcpy
mov [rbp+var_1], 0
loc_74918:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char ma_set_dynamic(long long a1, long long a2, unsigned int a3)
{
long long v4; // [rsp+8h] [rbp-28h]
unsigned int v5; // [rsp+10h] [rbp-20h]
if ( a3 < *(_DWORD *)(a1 + 8) )
goto LABEL_7;
if ( a3 < *(_DWORD *)(a1 + 12) )
{
LABEL_6:
memset(
(unsigned int)(*(_DWORD *)(a1 + 20) * *(_DWORD *)(a1 + 8)) + *(_QWORD *)a1,
0LL,
*(_DWORD *)(a1 + 20) * (a3 - *(_DWORD *)(a1 + 8)));
*(_DWORD *)(a1 + 8) = a3 + 1;
LABEL_7:
memcpy(*(_DWORD *)(a1 + 20) * a3 + *(_QWORD *)a1, a2, *(unsigned int *)(a1 + 20));
return 0;
}
v5 = (*(_DWORD *)(a1 + 16) + a3) / *(_DWORD *)(a1 + 16) * *(_DWORD *)(a1 + 16);
v4 = realloc(*(_QWORD *)a1, *(_DWORD *)(a1 + 20) * v5);
if ( v4 )
{
*(_QWORD *)a1 = v4;
*(_DWORD *)(a1 + 12) = v5;
goto LABEL_6;
}
return 1;
}
| ma_set_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x8]
JC 0x001748eb
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JC 0x001748a6
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV dword ptr [RCX + 0x10]
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
IMUL EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV ESI,EAX
CALL 0x001380c0
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JNZ 0x00174891
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00174918
LAB_00174891:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xc],ECX
LAB_001748a6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
SUB EAX,dword ptr [RCX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x00138300
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x8],ECX
LAB_001748eb:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
MOV EDX,EAX
CALL 0x001380b0
MOV byte ptr [RBP + -0x1],0x0
LAB_00174918:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 ma_set_dynamic(long *param_1,void *param_2,uint param_3)
{
int iVar1;
void *pvVar2;
if (*(uint *)(param_1 + 1) <= param_3) {
if (*(uint *)((long)param_1 + 0xc) <= param_3) {
iVar1 = (int)param_1[2] * ((param_3 + (int)param_1[2]) / *(uint *)(param_1 + 2));
pvVar2 = realloc((void *)*param_1,(ulong)(uint)(iVar1 * *(int *)((long)param_1 + 0x14)));
if (pvVar2 == (void *)0x0) {
return 1;
}
*param_1 = (long)pvVar2;
*(int *)((long)param_1 + 0xc) = iVar1;
}
memset((void *)(*param_1 + (ulong)(uint)((int)param_1[1] * *(int *)((long)param_1 + 0x14))),0,
(ulong)((param_3 - (int)param_1[1]) * *(int *)((long)param_1 + 0x14)));
*(uint *)(param_1 + 1) = param_3 + 1;
}
memcpy((void *)(*param_1 + (ulong)(param_3 * *(int *)((long)param_1 + 0x14))),param_2,
(ulong)*(uint *)((long)param_1 + 0x14));
return 0;
}
| |
51,231 | stbi__hdr_test_core(stbi__context*, char const*) | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | static int stbi__hdr_test_core(stbi__context *s, const char *signature)
{
int i;
for (i=0; signature[i]; ++i)
if (stbi__get8(s) != signature[i])
return 0;
stbi__rewind(s);
return 1;
} | O0 | c | stbi__hdr_test_core(stbi__context*, char const*):
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2ce6e
movq 0x18(%rsp), %rdi
callq 0x17f50
movzbl %al, %eax
movq 0x10(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x2ce5f
movl $0x0, 0x24(%rsp)
jmp 0x2ce80
jmp 0x2ce61
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2ce26
movq 0x18(%rsp), %rdi
callq 0x17f10
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
| _ZL19stbi__hdr_test_coreP13stbi__contextPKc:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov [rsp+28h+var_1C], 0
loc_2CE26:
mov rax, [rsp+28h+var_18]
movsxd rcx, [rsp+28h+var_1C]
cmp byte ptr [rax+rcx], 0
jz short loc_2CE6E
mov rdi, [rsp+28h+var_10]
call _ZL10stbi__get8P13stbi__context; stbi__get8(stbi__context *)
movzx eax, al
mov rcx, [rsp+28h+var_18]
movsxd rdx, [rsp+28h+var_1C]
movsx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_2CE5F
mov [rsp+28h+var_4], 0
jmp short loc_2CE80
loc_2CE5F:
jmp short $+2
loc_2CE61:
mov eax, [rsp+28h+var_1C]
add eax, 1
mov [rsp+28h+var_1C], eax
jmp short loc_2CE26
loc_2CE6E:
mov rdi, [rsp+28h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+28h+var_4], 1
loc_2CE80:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long stbi__hdr_test_core(_QWORD *a1, long long a2)
{
int i; // [rsp+Ch] [rbp-1Ch]
for ( i = 0; *(_BYTE *)(a2 + i); ++i )
{
if ( (unsigned __int8)stbi__get8((long long)a1) != *(char *)(a2 + i) )
return 0;
}
stbi__rewind(a1);
return 1;
}
| stbi__hdr_test_core:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV dword ptr [RSP + 0xc],0x0
LAB_0012ce26:
MOV RAX,qword ptr [RSP + 0x10]
MOVSXD RCX,dword ptr [RSP + 0xc]
CMP byte ptr [RAX + RCX*0x1],0x0
JZ 0x0012ce6e
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00117f50
MOVZX EAX,AL
MOV RCX,qword ptr [RSP + 0x10]
MOVSXD RDX,dword ptr [RSP + 0xc]
MOVSX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x0012ce5f
MOV dword ptr [RSP + 0x24],0x0
JMP 0x0012ce80
LAB_0012ce5f:
JMP 0x0012ce61
LAB_0012ce61:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x0012ce26
LAB_0012ce6e:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00117f10
MOV dword ptr [RSP + 0x24],0x1
LAB_0012ce80:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
/* stbi__hdr_test_core(stbi__context*, char const*) */
int4 stbi__hdr_test_core(stbi__context *param_1,char *param_2)
{
byte bVar1;
int local_1c;
local_1c = 0;
while( true ) {
if (param_2[local_1c] == '\0') {
stbi__rewind(param_1);
return 1;
}
bVar1 = stbi__get8(param_1);
if ((uint)bVar1 != (int)param_2[local_1c]) break;
local_1c = local_1c + 1;
}
return 0;
}
| |
51,232 | stbi__hdr_test_core(stbi__context*, char const*) | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | static int stbi__hdr_test_core(stbi__context *s, const char *signature)
{
int i;
for (i=0; signature[i]; ++i)
if (stbi__get8(s) != signature[i])
return 0;
stbi__rewind(s);
return 1;
} | O1 | c | stbi__hdr_test_core(stbi__context*, char const*):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, (%rsi)
je 0x2e2ce
movq %rsi, %r14
incq %r14
movq 0xc0(%rbx), %rax
cmpq 0xc8(%rbx), %rax
jb 0x2e2a7
cmpl $0x0, 0x30(%rbx)
je 0x2e2ca
movq %rbx, %rdi
callq 0x2696c
movq 0xc0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc0(%rbx)
movzbl (%rax), %eax
movsbl -0x1(%r14), %ecx
cmpl %ecx, %eax
jne 0x2e2e3
cmpb $0x0, (%r14)
leaq 0x1(%r14), %r14
jne 0x2e282
jmp 0x2e2ce
xorl %eax, %eax
jmp 0x2e2b5
movups 0xd0(%rbx), %xmm0
movups %xmm0, 0xc0(%rbx)
movl $0x1, %eax
jmp 0x2e2e5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZL19stbi__hdr_test_coreP13stbi__contextPKc:
push r14
push rbx
push rax
mov rbx, rdi
cmp byte ptr [rsi], 0
jz short loc_2E2CE
mov r14, rsi
inc r14
loc_2E282:
mov rax, [rbx+0C0h]
cmp rax, [rbx+0C8h]
jb short loc_2E2A7
cmp dword ptr [rbx+30h], 0
jz short loc_2E2CA
mov rdi, rbx
call _ZL19stbi__refill_bufferP13stbi__context; stbi__refill_buffer(stbi__context *)
mov rax, [rbx+0C0h]
loc_2E2A7:
lea rcx, [rax+1]
mov [rbx+0C0h], rcx
movzx eax, byte ptr [rax]
loc_2E2B5:
movsx ecx, byte ptr [r14-1]
cmp eax, ecx
jnz short loc_2E2E3
cmp byte ptr [r14], 0
lea r14, [r14+1]
jnz short loc_2E282
jmp short loc_2E2CE
loc_2E2CA:
xor eax, eax
jmp short loc_2E2B5
loc_2E2CE:
movups xmm0, xmmword ptr [rbx+0D0h]
movups xmmword ptr [rbx+0C0h], xmm0
mov eax, 1
jmp short loc_2E2E5
loc_2E2E3:
xor eax, eax
loc_2E2E5:
add rsp, 8
pop rbx
pop r14
retn
| long long stbi__hdr_test_core(long long a1, _BYTE *a2)
{
_BYTE *v2; // r14
unsigned __int8 *v3; // rax
int v4; // eax
if ( !*a2 )
{
LABEL_11:
*(_OWORD *)(a1 + 192) = *(_OWORD *)(a1 + 208);
return 1LL;
}
v2 = a2 + 1;
while ( 1 )
{
v3 = *(unsigned __int8 **)(a1 + 192);
if ( (unsigned long long)v3 < *(_QWORD *)(a1 + 200) )
goto LABEL_6;
if ( *(_DWORD *)(a1 + 48) )
{
stbi__refill_buffer(a1);
v3 = *(unsigned __int8 **)(a1 + 192);
LABEL_6:
*(_QWORD *)(a1 + 192) = v3 + 1;
v4 = *v3;
goto LABEL_7;
}
v4 = 0;
LABEL_7:
if ( v4 != (char)*(v2 - 1) )
return 0LL;
if ( *v2++ == 0 )
goto LABEL_11;
}
}
| |||
51,233 | stbi__hdr_test_core(stbi__context*, char const*) | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | static int stbi__hdr_test_core(stbi__context *s, const char *signature)
{
int i;
for (i=0; signature[i]; ++i)
if (stbi__get8(s) != signature[i])
return 0;
stbi__rewind(s);
return 1;
} | O3 | c | stbi__hdr_test_core(stbi__context*, char const*):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x2d532
movq %rsi, %r14
movq 0xc0(%rbx), %rax
incq %r14
cmpq 0xc8(%rbx), %rax
jb 0x2d506
cmpl $0x0, 0x30(%rbx)
je 0x2d52e
movq %rbx, %rdi
callq 0x2620e
movq 0xc0(%rbx), %rax
leaq 0x1(%rax), %rsi
movq %rsi, 0xc0(%rbx)
movzbl (%rax), %edx
movb -0x1(%r14), %cl
movq %rsi, %rax
movsbl %cl, %ecx
cmpl %ecx, %edx
jne 0x2d547
movb (%r14), %cl
incq %r14
testb %cl, %cl
jne 0x2d4e8
jmp 0x2d532
xorl %edx, %edx
jmp 0x2d51b
movups 0xd0(%rbx), %xmm0
movups %xmm0, 0xc0(%rbx)
movl $0x1, %eax
jmp 0x2d549
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZL19stbi__hdr_test_coreP13stbi__contextPKc:
push r14
push rbx
push rax
mov rbx, rdi
mov cl, [rsi]
test cl, cl
jz short loc_2D532
mov r14, rsi
mov rax, [rbx+0C0h]
inc r14
loc_2D4E8:
cmp rax, [rbx+0C8h]
jb short loc_2D506
cmp dword ptr [rbx+30h], 0
jz short loc_2D52E
mov rdi, rbx
call _ZL19stbi__refill_bufferP13stbi__context; stbi__refill_buffer(stbi__context *)
mov rax, [rbx+0C0h]
loc_2D506:
lea rsi, [rax+1]
mov [rbx+0C0h], rsi
movzx edx, byte ptr [rax]
mov cl, [r14-1]
mov rax, rsi
loc_2D51B:
movsx ecx, cl
cmp edx, ecx
jnz short loc_2D547
mov cl, [r14]
inc r14
test cl, cl
jnz short loc_2D4E8
jmp short loc_2D532
loc_2D52E:
xor edx, edx
jmp short loc_2D51B
loc_2D532:
movups xmm0, xmmword ptr [rbx+0D0h]
movups xmmword ptr [rbx+0C0h], xmm0
mov eax, 1
jmp short loc_2D549
loc_2D547:
xor eax, eax
loc_2D549:
add rsp, 8
pop rbx
pop r14
retn
| long long stbi__hdr_test_core(long long a1, char *a2)
{
char v2; // cl
unsigned __int8 *v3; // rax
char *v4; // r14
int v5; // edx
v2 = *a2;
if ( !*a2 )
{
LABEL_11:
*(_OWORD *)(a1 + 192) = *(_OWORD *)(a1 + 208);
return 1LL;
}
v3 = *(unsigned __int8 **)(a1 + 192);
v4 = a2 + 1;
while ( 1 )
{
if ( (unsigned long long)v3 < *(_QWORD *)(a1 + 200) )
goto LABEL_6;
if ( *(_DWORD *)(a1 + 48) )
{
stbi__refill_buffer(a1);
v3 = *(unsigned __int8 **)(a1 + 192);
LABEL_6:
*(_QWORD *)(a1 + 192) = v3 + 1;
v5 = *v3;
v2 = *(v4 - 1);
++v3;
goto LABEL_7;
}
v5 = 0;
LABEL_7:
if ( v5 != v2 )
return 0LL;
v2 = *v4++;
if ( !v2 )
goto LABEL_11;
}
}
| |||
51,234 | re_emit_range | bluesky950520[P]quickjs/libregexp.c | static int re_emit_range(REParseState *s, const CharRange *cr)
{
int len, i;
uint32_t high;
len = (unsigned)cr->len / 2;
if (len >= 65535)
return re_parse_error(s, "too many ranges");
if (len == 0) {
/* not sure it can really happen. Emit a match that is always
false */
re_emit_op_u32(s, REOP_char32, -1);
} else {
high = cr->points[cr->len - 1];
if (high == UINT32_MAX)
high = cr->points[cr->len - 2];
if (high <= 0xffff) {
/* can use 16 bit ranges with the conversion that 0xffff =
infinity */
re_emit_op_u16(s, REOP_range, len);
for(i = 0; i < cr->len; i += 2) {
dbuf_put_u16(&s->byte_code, cr->points[i]);
high = cr->points[i + 1] - 1;
if (high == UINT32_MAX - 1)
high = 0xffff;
dbuf_put_u16(&s->byte_code, high);
}
} else {
re_emit_op_u16(s, REOP_range32, len);
for(i = 0; i < cr->len; i += 2) {
dbuf_put_u32(&s->byte_code, cr->points[i]);
dbuf_put_u32(&s->byte_code, cr->points[i + 1] - 1);
}
}
}
return 0;
} | O2 | c | re_emit_range:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %edx
cmpq $0x1fffe, %rdx # imm = 0x1FFFE
jb 0x82802
leaq 0xb053(%rip), %rsi # 0x8d845
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7fb74
pushq $-0x1
popq %r15
jmp 0x82818
cmpl $0x1, %edx
ja 0x82824
pushq $0x3
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7fa43
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movq 0x8(%rsi), %rcx
movl -0x4(%rcx,%rdx,4), %eax
cmpl $-0x1, %eax
jne 0x82838
movl -0x8(%rcx,%rdx,4), %eax
shrl %edx
cmpl $0xffff, %eax # imm = 0xFFFF
ja 0x82892
pushq $0x16
popq %rsi
movq %rbx, %rdi
callq 0x828d8
xorl %r15d, %r15d
movl $0xffff, %ebp # imm = 0xFFFF
xorl %r12d, %r12d
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x82818
movq 0x8(%r14), %rax
movzwl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x7fa18
movq 0x8(%r14), %rax
movl 0x4(%rax,%r12,4), %eax
decl %eax
cmpl $-0x2, %eax
cmovel %ebp, %eax
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x7fa18
addq $0x2, %r12
jmp 0x82857
pushq $0x17
popq %rsi
movq %rbx, %rdi
callq 0x828d8
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x82818
movq 0x8(%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x7fa2e
movq 0x8(%r14), %rax
movl 0x4(%rax,%r12,4), %esi
decl %esi
movq %rbx, %rdi
callq 0x7fa2e
addq $0x2, %r12
jmp 0x828a3
| re_emit_range:
push rbp
push r15
push r14
push r12
push rbx
mov rbx, rdi
mov edx, [rsi]
cmp rdx, offset loc_1FFFE
jb short loc_82802
lea rsi, aTooManyRanges; "too many ranges"
mov rdi, rbx
xor eax, eax
call re_parse_error
push 0FFFFFFFFFFFFFFFFh
pop r15
jmp short loc_82818
loc_82802:
cmp edx, 1
ja short loc_82824
push 3
pop rsi
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rdi, rbx
call re_emit_op_u32
xor r15d, r15d
loc_82818:
mov eax, r15d
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_82824:
mov r14, rsi
mov rcx, [rsi+8]
mov eax, [rcx+rdx*4-4]
cmp eax, 0FFFFFFFFh
jnz short loc_82838
mov eax, [rcx+rdx*4-8]
loc_82838:
shr edx, 1
cmp eax, 0FFFFh
ja short loc_82892
push 16h
pop rsi
mov rdi, rbx
call re_emit_op_u16
xor r15d, r15d
mov ebp, 0FFFFh
xor r12d, r12d
loc_82857:
movsxd rax, dword ptr [r14]
cmp r12, rax
jge short loc_82818
mov rax, [r14+8]
movzx esi, word ptr [rax+r12*4]
mov rdi, rbx
call dbuf_put_u16_0
mov rax, [r14+8]
mov eax, [rax+r12*4+4]
dec eax
cmp eax, 0FFFFFFFEh
cmovz eax, ebp
movzx esi, ax
mov rdi, rbx
call dbuf_put_u16_0
add r12, 2
jmp short loc_82857
loc_82892:
push 17h
pop rsi
mov rdi, rbx
call re_emit_op_u16
xor r15d, r15d
xor r12d, r12d
loc_828A3:
movsxd rax, dword ptr [r14]
cmp r12, rax
jge loc_82818
mov rax, [r14+8]
mov esi, [rax+r12*4]
mov rdi, rbx
call dbuf_put_u32_0
mov rax, [r14+8]
mov esi, [rax+r12*4+4]
dec esi
mov rdi, rbx
call dbuf_put_u32_0
add r12, 2
jmp short loc_828A3
| long long re_emit_range(
_QWORD *a1,
unsigned int *a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
unsigned long long v14; // rdx
unsigned int v15; // r15d
long long v17; // rcx
unsigned int v18; // eax
long long v19; // rdx
long long j; // r12
int v21; // eax
long long i; // r12
char v23; // [rsp+0h] [rbp-28h]
v14 = *a2;
if ( v14 < (unsigned long long)&loc_1FFFE )
{
if ( (unsigned int)v14 > 1 )
{
v17 = *((_QWORD *)a2 + 1);
v18 = *(_DWORD *)(v17 + 4 * v14 - 4);
if ( v18 == -1 )
v18 = *(_DWORD *)(v17 + 4 * v14 - 8);
v19 = (unsigned int)v14 >> 1;
if ( v18 > 0xFFFF )
{
re_emit_op_u16(a1, 23LL, v19);
v15 = 0;
for ( i = 0LL; i < (int)*a2; i += 2LL )
{
dbuf_put_u32_0(a1, *(_DWORD *)(*((_QWORD *)a2 + 1) + 4 * i));
dbuf_put_u32_0(a1, *(_DWORD *)(*((_QWORD *)a2 + 1) + 4 * i + 4) - 1);
}
}
else
{
re_emit_op_u16(a1, 22LL, v19);
v15 = 0;
for ( j = 0LL; j < (int)*a2; j += 2LL )
{
dbuf_put_u16_0(a1, *(_WORD *)(*((_QWORD *)a2 + 1) + 4 * j));
v21 = *(_DWORD *)(*((_QWORD *)a2 + 1) + 4 * j + 4) - 1;
if ( *(_DWORD *)(*((_QWORD *)a2 + 1) + 4 * j + 4) == -1 )
LOWORD(v21) = -1;
dbuf_put_u16_0(a1, v21);
}
}
}
else
{
re_emit_op_u32((long long)a1, 3, 0xFFFFFFFF);
return 0;
}
}
else
{
re_parse_error((long long)a1, (long long)"too many ranges", v14, a12, a13, a14, a3, a4, a5, a6, a7, a8, a9, a10, v23);
return (unsigned int)-1;
}
return v15;
}
| re_emit_range:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV EDX,dword ptr [RSI]
CMP RDX,0x1fffe
JC 0x00182802
LEA RSI,[0x18d845]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0017fb74
PUSH -0x1
POP R15
JMP 0x00182818
LAB_00182802:
CMP EDX,0x1
JA 0x00182824
PUSH 0x3
POP RSI
PUSH -0x1
POP RDX
MOV RDI,RBX
CALL 0x0017fa43
XOR R15D,R15D
LAB_00182818:
MOV EAX,R15D
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00182824:
MOV R14,RSI
MOV RCX,qword ptr [RSI + 0x8]
MOV EAX,dword ptr [RCX + RDX*0x4 + -0x4]
CMP EAX,-0x1
JNZ 0x00182838
MOV EAX,dword ptr [RCX + RDX*0x4 + -0x8]
LAB_00182838:
SHR EDX,0x1
CMP EAX,0xffff
JA 0x00182892
PUSH 0x16
POP RSI
MOV RDI,RBX
CALL 0x001828d8
XOR R15D,R15D
MOV EBP,0xffff
XOR R12D,R12D
LAB_00182857:
MOVSXD RAX,dword ptr [R14]
CMP R12,RAX
JGE 0x00182818
MOV RAX,qword ptr [R14 + 0x8]
MOVZX ESI,word ptr [RAX + R12*0x4]
MOV RDI,RBX
CALL 0x0017fa18
MOV RAX,qword ptr [R14 + 0x8]
MOV EAX,dword ptr [RAX + R12*0x4 + 0x4]
DEC EAX
CMP EAX,-0x2
CMOVZ EAX,EBP
MOVZX ESI,AX
MOV RDI,RBX
CALL 0x0017fa18
ADD R12,0x2
JMP 0x00182857
LAB_00182892:
PUSH 0x17
POP RSI
MOV RDI,RBX
CALL 0x001828d8
XOR R15D,R15D
XOR R12D,R12D
LAB_001828a3:
MOVSXD RAX,dword ptr [R14]
CMP R12,RAX
JGE 0x00182818
MOV RAX,qword ptr [R14 + 0x8]
MOV ESI,dword ptr [RAX + R12*0x4]
MOV RDI,RBX
CALL 0x0017fa2e
MOV RAX,qword ptr [R14 + 0x8]
MOV ESI,dword ptr [RAX + R12*0x4 + 0x4]
DEC ESI
MOV RDI,RBX
CALL 0x0017fa2e
ADD R12,0x2
JMP 0x001828a3
|
int4 re_emit_range(int8 param_1,uint *param_2)
{
uint uVar1;
int2 uVar2;
uint uVar3;
int iVar4;
ulong uVar5;
long lVar6;
int4 uVar7;
uVar1 = *param_2;
uVar5 = (ulong)uVar1;
if (uVar5 < 0x1fffe) {
if (uVar1 < 2) {
re_emit_op_u32(param_1,3,0xffffffffffffffff);
uVar7 = 0;
}
else {
uVar3 = *(uint *)(*(long *)(param_2 + 2) + -4 + uVar5 * 4);
if (uVar3 == 0xffffffff) {
uVar3 = *(uint *)(*(long *)(param_2 + 2) + -8 + uVar5 * 4);
}
if (uVar3 < 0x10000) {
re_emit_op_u16(param_1,0x16,uVar1 >> 1);
uVar7 = 0;
for (lVar6 = 0; lVar6 < (int)*param_2; lVar6 = lVar6 + 2) {
dbuf_put_u16(param_1,*(int2 *)(*(long *)(param_2 + 2) + lVar6 * 4));
iVar4 = *(int *)(*(long *)(param_2 + 2) + 4 + lVar6 * 4) + -1;
uVar2 = (int2)iVar4;
if (iVar4 == -2) {
uVar2 = 0xffff;
}
dbuf_put_u16(param_1,uVar2);
}
}
else {
re_emit_op_u16(param_1,0x17,uVar1 >> 1);
uVar7 = 0;
for (lVar6 = 0; lVar6 < (int)*param_2; lVar6 = lVar6 + 2) {
dbuf_put_u32(param_1,*(int4 *)(*(long *)(param_2 + 2) + lVar6 * 4));
dbuf_put_u32(param_1,*(int *)(*(long *)(param_2 + 2) + 4 + lVar6 * 4) + -1);
}
}
}
}
else {
re_parse_error(param_1,"too many ranges");
uVar7 = 0xffffffff;
}
return uVar7;
}
| |
51,235 | minja::Value::insert(unsigned long, minja::Value const&) | monkey531[P]llama/common/./minja.hpp | void insert(size_t index, const Value& v) {
if (!array_)
throw std::runtime_error("Value is not an array: " + dump());
array_->insert(array_->begin() + index, v);
} | O0 | cpp | minja::Value::insert(unsigned long, minja::Value const&):
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x10, %rdi
callq 0x9ff80
testb $0x1, %al
jne 0xd976b
movb $0x1, 0x43(%rsp)
movl $0x10, %edi
callq 0x50540
movq 0x18(%rsp), %rsi
movq %rax, 0x10(%rsp)
leaq 0x50(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x9feb0
jmp 0xd96c9
leaq 0xf7e58(%rip), %rsi # 0x1d1528
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x7a6e0
jmp 0xd96e1
movq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x50390
jmp 0xd96f2
movq 0x10(%rsp), %rdi
movb $0x0, 0x43(%rsp)
movq 0x17a8ad(%rip), %rsi # 0x253fb0
movq 0x17a86e(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0xd97ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xd9756
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xd974c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x510c0
leaq 0x50(%rsp), %rdi
callq 0x510c0
testb $0x1, 0x43(%rsp)
jne 0xd975f
jmp 0xd9769
movq 0x10(%rsp), %rdi
callq 0x50c40
jmp 0xd97e3
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
callq 0xa19f0
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
callq 0xa19f0
movq %rax, %rdi
callq 0xcb940
movq %rax, 0x28(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xdc170
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xdc220
movq 0x8(%rsp), %rdi
movq 0x90(%rsp), %rdx
movq 0x38(%rsp), %rsi
callq 0xdcfb0
movq %rax, 0x20(%rsp)
addq $0xa8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x50940
nopl (%rax)
| _ZN5minja5Value6insertEmRKS0_:
sub rsp, 0A8h
mov [rsp+0A8h+var_8], rdi
mov [rsp+0A8h+var_10], rsi
mov [rsp+0A8h+var_18], rdx
mov rdi, [rsp+0A8h+var_8]
mov [rsp+0A8h+var_90], rdi
add rdi, 10h
call _ZNKSt12__shared_ptrISt6vectorIN5minja5ValueESaIS2_EELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz loc_D976B
mov [rsp+0A8h+var_65], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rsi, [rsp+0A8h+var_90]
mov [rsp+0A8h+var_98], rax
lea rdi, [rsp+0A8h+var_58]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_D96C9:
lea rsi, aValueIsNotAnAr; "Value is not an array: "
lea rdi, [rsp+0A8h+var_38]
lea rdx, [rsp+0A8h+var_58]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_D96E1:
mov rdi, [rsp+0A8h+var_98]
lea rsi, [rsp+0A8h+var_38]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_D96F2:
mov rdi, [rsp+0A8h+var_98]; void *
mov [rsp+0A8h+var_65], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_D97ED
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
jmp short loc_D9756
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
jmp short loc_D974C
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_D974C:
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_D9756:
test [rsp+arg_3B], 1
jnz short loc_D975F
jmp short loc_D9769
loc_D975F:
mov rdi, [rsp+arg_8]; void *
call ___cxa_free_exception
loc_D9769:
jmp short loc_D97E3
loc_D976B:
mov rdi, [rsp+0A8h+var_90]
add rdi, 10h
call _ZNKSt19__shared_ptr_accessISt6vectorIN5minja5ValueESaIS2_EELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, [rsp+0A8h+var_90]
mov [rsp+0A8h+var_A0], rax
add rdi, 10h
call _ZNKSt19__shared_ptr_accessISt6vectorIN5minja5ValueESaIS2_EELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
call _ZNSt6vectorIN5minja5ValueESaIS1_EE5beginEv; std::vector<minja::Value>::begin(void)
mov [rsp+0A8h+var_80], rax
mov rsi, [rsp+0A8h+var_10]
lea rdi, [rsp+0A8h+var_80]
call _ZNK9__gnu_cxx17__normal_iteratorIPN5minja5ValueESt6vectorIS2_SaIS2_EEEplEl; __gnu_cxx::__normal_iterator<minja::Value *,std::vector<minja::Value>>::operator+(long)
mov [rsp+0A8h+var_78], rax
lea rdi, [rsp+0A8h+var_70]
lea rsi, [rsp+0A8h+var_78]
call _ZN9__gnu_cxx17__normal_iteratorIPKN5minja5ValueESt6vectorIS2_SaIS2_EEEC2IPS2_EERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISB_SA_EE7__valueES7_E6__typeEEE
mov rdi, [rsp+0A8h+var_A0]
mov rdx, [rsp+0A8h+var_18]
mov rsi, [rsp+0A8h+var_70]
call _ZNSt6vectorIN5minja5ValueESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPKS1_S3_EERS6_; std::vector<minja::Value>::insert(__gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>,minja::Value const&)
mov [rsp+0A8h+var_88], rax
add rsp, 0A8h
retn
loc_D97E3:
mov rdi, [rsp+arg_40]
call __Unwind_Resume
loc_D97ED:
nop dword ptr [rax]
| long long minja::Value::insert(minja::Value *this, long long a2, const minja::Value *a3)
{
long long v3; // rax
int v4; // ecx
int v5; // r8d
int v6; // r9d
int v8; // [rsp+8h] [rbp-A0h]
void *exception; // [rsp+10h] [rbp-98h]
long long v10; // [rsp+28h] [rbp-80h] BYREF
long long v11; // [rsp+30h] [rbp-78h] BYREF
long long v12; // [rsp+38h] [rbp-70h] BYREF
char v13; // [rsp+43h] [rbp-65h]
_BYTE v14[32]; // [rsp+50h] [rbp-58h] BYREF
_BYTE v15[32]; // [rsp+70h] [rbp-38h] BYREF
const minja::Value *v16; // [rsp+90h] [rbp-18h]
long long v17; // [rsp+98h] [rbp-10h]
minja::Value *v18; // [rsp+A0h] [rbp-8h]
v18 = this;
v17 = a2;
v16 = a3;
if ( !std::__shared_ptr<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2>::operator bool((_QWORD *)this + 2) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v14, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v15, (long long)"Value is not an array: ", (long long)v14);
std::runtime_error::runtime_error(exception, v15);
v13 = 0;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v8 = std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((long long)this + 16);
v3 = std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((long long)this + 16);
v10 = std::vector<minja::Value>::begin(v3);
v11 = __gnu_cxx::__normal_iterator<minja::Value *,std::vector<minja::Value>>::operator+(&v10, v17);
__gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>::__normal_iterator<minja::Value*>(
&v12,
&v11);
return std::vector<minja::Value>::insert(v8, v12, (_DWORD)v16, v4, v5, v6);
}
| insert:
SUB RSP,0xa8
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],RSI
MOV qword ptr [RSP + 0x90],RDX
MOV RDI,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x18],RDI
ADD RDI,0x10
CALL 0x0019ff80
TEST AL,0x1
JNZ 0x001d976b
MOV byte ptr [RSP + 0x43],0x1
MOV EDI,0x10
CALL 0x00150540
MOV RSI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x10],RAX
LAB_001d96b6:
LEA RDI,[RSP + 0x50]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0019feb0
JMP 0x001d96c9
LAB_001d96c9:
LEA RSI,[0x2d1528]
LEA RDI,[RSP + 0x70]
LEA RDX,[RSP + 0x50]
CALL 0x0017a6e0
JMP 0x001d96e1
LAB_001d96e1:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x70]
CALL 0x00150390
JMP 0x001d96f2
LAB_001d96f2:
MOV RDI,qword ptr [RSP + 0x10]
MOV byte ptr [RSP + 0x43],0x0
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
LAB_001d976b:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x10
CALL 0x001a19f0
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
ADD RDI,0x10
CALL 0x001a19f0
MOV RDI,RAX
CALL 0x001cb940
MOV qword ptr [RSP + 0x28],RAX
MOV RSI,qword ptr [RSP + 0x98]
LEA RDI,[RSP + 0x28]
CALL 0x001dc170
MOV qword ptr [RSP + 0x30],RAX
LEA RDI,[RSP + 0x38]
LEA RSI,[RSP + 0x30]
CALL 0x001dc220
MOV RDI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x001dcfb0
MOV qword ptr [RSP + 0x20],RAX
ADD RSP,0xa8
RET
|
/* minja::Value::insert(unsigned long, minja::Value const&) */
void __thiscall minja::Value::insert(Value *this,ulong param_1,Value *param_2)
{
runtime_error *this_00;
vector<minja::Value,std::allocator<minja::Value>> *pvVar1;
vector<minja::Value,std::allocator<minja::Value>> *this_01;
bool bVar2;
int8 local_80;
int8 local_78;
int8 local_70;
int1 local_65;
int1 local_58 [32];
string local_38 [32];
Value *local_18;
ulong local_10;
Value *local_8;
local_18 = param_2;
local_10 = param_1;
local_8 = this;
bVar2 = std::__shared_ptr::operator_cast_to_bool((__shared_ptr *)(this + 0x10));
if (!bVar2) {
local_65 = 1;
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001d96b6 to 001d96c6 has its CatchHandler @ 001d9714 */
dump_abi_cxx11_((int)local_58,SUB81(this,0));
/* try { // try from 001d96c9 to 001d96de has its CatchHandler @ 001d9724 */
std::operator+((char *)local_38,(string *)"Value is not an array: ");
/* try { // try from 001d96e1 to 001d970e has its CatchHandler @ 001d9734 */
std::runtime_error::runtime_error(this_00,local_38);
local_65 = 0;
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
pvVar1 = (vector<minja::Value,std::allocator<minja::Value>> *)
std::
__shared_ptr_access<std::vector<minja::Value,std::allocator<minja::Value>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<std::vector<minja::Value,std::allocator<minja::Value>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x10));
this_01 = (vector<minja::Value,std::allocator<minja::Value>> *)
std::
__shared_ptr_access<std::vector<minja::Value,std::allocator<minja::Value>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<std::vector<minja::Value,std::allocator<minja::Value>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x10));
local_80 = std::vector<minja::Value,std::allocator<minja::Value>>::begin(this_01);
local_78 = __gnu_cxx::
__normal_iterator<minja::Value*,std::vector<minja::Value,std::allocator<minja::Value>>>
::operator+((__normal_iterator<minja::Value*,std::vector<minja::Value,std::allocator<minja::Value>>>
*)&local_80,local_10);
__gnu_cxx::
__normal_iterator<minja::Value_const*,std::vector<minja::Value,std::allocator<minja::Value>>>::
__normal_iterator<minja::Value*>
((__normal_iterator<minja::Value_const*,std::vector<minja::Value,std::allocator<minja::Value>>>
*)&local_70,(__normal_iterator *)&local_78);
std::vector<minja::Value,std::allocator<minja::Value>>::insert(pvVar1,local_70,local_18);
return;
}
| |
51,236 | minja::Value::insert(unsigned long, minja::Value const&) | monkey531[P]llama/common/./minja.hpp | void insert(size_t index, const Value& v) {
if (!array_)
throw std::runtime_error("Value is not an array: " + dump());
array_->insert(array_->begin() + index, v);
} | O2 | cpp | minja::Value::insert(unsigned long, minja::Value const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x4de5a
imulq $0x50, %rsi, %rsi
addq (%rdi), %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4eeee
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %rbx
movq %rsp, %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3b614
leaq 0x5026c(%rip), %rsi # 0x9e0e8
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30398
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x20aa0
xorl %ebp, %ebp
movq 0x94146(%rip), %rsi # 0xe1fe8
movq 0x940c7(%rip), %rdx # 0xe1f70
movq %rbx, %rdi
callq 0x20b30
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x20d78
jmp 0x4dec6
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x20d78
testb %bpl, %bpl
jne 0x4ded8
jmp 0x4dee0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20520
movq %r14, %rdi
callq 0x20b90
| _ZN5minja5Value6insertEmRKS0_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
mov rdi, [rdi+10h]
test rdi, rdi
jz short loc_4DE5A
imul rsi, 50h ; 'P'
add rsi, [rdi]
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN5minja5ValueESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPKS1_S3_EERS6_; std::vector<minja::Value>::insert(__gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>,minja::Value const&)
loc_4DE5A:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr; "Value is not an array: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+58h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_4DEC6
mov r14, rax
mov bpl, 1
loc_4DEC6:
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_4DED8
jmp short loc_4DEE0
mov r14, rax
loc_4DED8:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_4DEE0:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::insert(minja::Value *this, long long a2, const minja::Value *a3)
{
_QWORD *v4; // rdi
void *exception; // rbx
_BYTE v7[32]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v8[56]; // [rsp+20h] [rbp-38h] BYREF
v4 = (_QWORD *)*((_QWORD *)this + 2);
if ( !v4 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v7, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v8, (long long)"Value is not an array: ", (long long)v7);
std::runtime_error::runtime_error(exception, v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return std::vector<minja::Value>::insert(v4, *v4 + 80 * a2, a3);
}
| |||
51,237 | minja::Value::insert(unsigned long, minja::Value const&) | monkey531[P]llama/common/./minja.hpp | void insert(size_t index, const Value& v) {
if (!array_)
throw std::runtime_error("Value is not an array: " + dump());
array_->insert(array_->begin() + index, v);
} | O3 | cpp | minja::Value::insert(unsigned long, minja::Value const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x54532
leaq (%rsi,%rsi,4), %rsi
shlq $0x4, %rsi
addq (%rdi), %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x55c6a
movl $0x10, %edi
callq 0x18360
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x6681a(%rip), %rsi # 0xbad72
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9ba72(%rip), %rsi # 0xefff0
movq 0x9b9fb(%rip), %rdx # 0xeff80
movq %rbx, %rdi
callq 0x18b30
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x545ab
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x545c6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
testb %bpl, %bpl
jne 0x545f0
jmp 0x545f8
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x545f0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x545f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x18500
movq %r14, %rdi
callq 0x18b90
| _ZN5minja5Value6insertEmRKS0_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
mov rdi, [rdi+10h]
test rdi, rdi
jz short loc_54532
lea rsi, [rsi+rsi*4]
shl rsi, 4
add rsi, [rdi]
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN5minja5ValueESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPKS1_S3_EERS6_; std::vector<minja::Value>::insert(__gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>,minja::Value const&)
loc_54532:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr; "Value is not an array: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_545AB
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_545AB:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_545C6
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_545C6:
test bpl, bpl
jnz short loc_545F0
jmp short loc_545F8
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_545F0
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_545F0
mov r14, rax
loc_545F0:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_545F8:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::insert(minja::Value *this, long long a2, const minja::Value *a3)
{
_QWORD *v4; // rdi
void *exception; // rbx
_BYTE v7[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v8[16]; // [rsp+20h] [rbp-38h] BYREF
v4 = (_QWORD *)*((_QWORD *)this + 2);
if ( !v4 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v7, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v8, (long long)"Value is not an array: ", (long long)v7);
std::runtime_error::runtime_error(exception, v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return std::vector<minja::Value>::insert(v4, *v4 + 80 * a2, a3);
}
| insert:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x10]
TEST RDI,RDI
JZ 0x00154532
LEA RSI,[RSI + RSI*0x4]
SHL RSI,0x4
ADD RSI,qword ptr [RDI]
ADD RSP,0x40
POP RBX
POP R14
POP RBP
JMP 0x00155c6a
LAB_00154532:
MOV EDI,0x10
CALL 0x00118360
MOV RBX,RAX
LAB_0015453f:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_00154551:
LEA RSI,[0x1bad72]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_00154568:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,RBX
CALL 0x00118b30
|
/* minja::Value::insert(unsigned long, minja::Value const&) */
void minja::Value::insert(ulong param_1,Value *param_2)
{
vector<minja::Value,std::allocator<minja::Value>> *pvVar1;
runtime_error *this;
int1 auStack_58 [32];
string local_38 [32];
pvVar1 = *(vector<minja::Value,std::allocator<minja::Value>> **)(param_1 + 0x10);
if (pvVar1 != (vector<minja::Value,std::allocator<minja::Value>> *)0x0) {
std::vector<minja::Value,std::allocator<minja::Value>>::insert
(pvVar1,(long)param_2 * 0x50 + *(long *)pvVar1);
return;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015453f to 00154550 has its CatchHandler @ 001545ed */
dump_abi_cxx11_((int)auStack_58,SUB81(param_1,0));
/* try { // try from 00154551 to 00154564 has its CatchHandler @ 001545cd */
std::operator+((char *)local_38,(string *)"Value is not an array: ");
/* try { // try from 00154568 to 0015458c has its CatchHandler @ 0015458d */
std::runtime_error::runtime_error(this,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
| |
51,238 | mysql_stmt_close_cont | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_close_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status)
{
MK_ASYNC_CONT_BODY(
stmt->mysql,
TRUE,
r_my_bool)
} | O3 | c | mysql_stmt_close_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %r15
cmpb $0x0, 0x15(%r15)
je 0x2c68e
movb $0x1, 0x14(%r15)
movl %edx, 0x4(%r15)
leaq 0x38(%r15), %rdi
callq 0x2d8b3
movb $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x2c6f1
movl (%r15), %r15d
jmp 0x2c767
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1c3b8(%rip), %rax # 0x48a60
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 0x1c39d(%rip), %rax # 0x48a70
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, (%rbx)
jmp 0x2c767
movb $0x0, 0x15(%r15)
js 0x2c6fe
movb 0x8(%r15), %al
jmp 0x2c762
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1c344(%rip), %rax # 0x48a60
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 0x1c329(%rip), %rax # 0x48a70
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, %al
movb %al, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mysql_stmt_close_cont:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
mov rcx, [rax+480h]
mov r15, [rcx+28h]
cmp byte ptr [r15+15h], 0
jz short loc_2C68E
mov byte ptr [r15+14h], 1
mov [r15+4], edx
lea rdi, [r15+38h]
call my_context_continue
mov byte ptr [r15+14h], 0
test eax, eax
jle short loc_2C6F1
mov r15d, [r15]
jmp loc_2C767
loc_2C68E:
mov dword ptr [rax+90h], 7DEh
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+70h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov byte ptr [rbx], 1
jmp short loc_2C767
loc_2C6F1:
mov byte ptr [r15+15h], 0
js short loc_2C6FE
mov al, [r15+8]
jmp short loc_2C762
loc_2C6FE:
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 al, 1
loc_2C762:
mov [rbx], al
xor r15d, r15d
loc_2C767:
mov eax, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysql_stmt_close_cont(char *a1, long long a2, unsigned int a3)
{
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
unsigned int v6; // r15d
char v7; // al
v3 = *(_QWORD *)(a2 + 56);
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
if ( *((_BYTE *)v4 + 21) )
{
*((_BYTE *)v4 + 20) = 1;
v4[1] = a3;
v5 = my_context_continue(v4 + 14);
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
*((_BYTE *)v4 + 21) = 0;
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 = *((_BYTE *)v4 + 8);
}
*a1 = v7;
return 0;
}
else
{
return *v4;
}
}
else
{
*(_DWORD *)(v3 + 144) = 2014;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
v6 = 0;
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[14], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
*a1 = 1;
}
return v6;
}
| mysql_stmt_close_cont:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
MOV RCX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RCX + 0x28]
CMP byte ptr [R15 + 0x15],0x0
JZ 0x0012c68e
MOV byte ptr [R15 + 0x14],0x1
MOV dword ptr [R15 + 0x4],EDX
LEA RDI,[R15 + 0x38]
CALL 0x0012d8b3
MOV byte ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0012c6f1
MOV R15D,dword ptr [R15]
JMP 0x0012c767
LAB_0012c68e:
MOV dword ptr [RAX + 0x90],0x7de
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x148a60]
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,[0x148a70]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV byte ptr [RBX],0x1
JMP 0x0012c767
LAB_0012c6f1:
MOV byte ptr [R15 + 0x15],0x0
JS 0x0012c6fe
MOV AL,byte ptr [R15 + 0x8]
JMP 0x0012c762
LAB_0012c6fe:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x148a60]
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,[0x148a70]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV AL,0x1
LAB_0012c762:
MOV byte ptr [RBX],AL
XOR R15D,R15D
LAB_0012c767:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_stmt_close_cont(int1 *param_1,long param_2,int4 param_3)
{
int4 *puVar1;
int1 uVar2;
int iVar3;
int4 uVar4;
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
if (*(char *)((long)puVar1 + 0x15) == '\0') {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7de;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
uVar4 = 0;
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),
PTR_s_Commands_out_of_sync__you_can_t_r_00148ae0,0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
*param_1 = 1;
}
else {
*(int1 *)(puVar1 + 5) = 1;
puVar1[1] = param_3;
iVar3 = my_context_continue(puVar1 + 0xe);
*(int1 *)(puVar1 + 5) = 0;
if (iVar3 < 1) {
*(int1 *)((long)puVar1 + 0x15) = 0;
if (iVar3 < 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_00148ab0,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar2 = 1;
}
else {
uVar2 = *(int1 *)(puVar1 + 2);
}
*param_1 = uVar2;
uVar4 = 0;
}
else {
uVar4 = *puVar1;
}
}
return uVar4;
}
| |
51,239 | partitioned_key_cache_write | eloqsql/mysys/mf_keycache.c | static
int partitioned_key_cache_write(PARTITIONED_KEY_CACHE_CB *keycache,
File file, void *file_extra,
my_off_t filepos, int level,
uchar *buff, uint length,
uint block_length __attribute__((unused)),
int dont_write)
{
uint w_length;
ulonglong *part_map= (ulonglong *) file_extra;
uint offset= (uint) (filepos % keycache->key_cache_block_size);
DBUG_ENTER("partitioned_key_cache_write");
DBUG_PRINT("enter",
("fd: %u pos: %lu length: %u block_length: %u"
" key_block_length: %u",
(uint) file, (ulong) filepos, length, block_length,
keycache ? keycache->key_cache_block_size : 0));
/* Write data in key_cache_block_size increments */
do
{
SIMPLE_KEY_CACHE_CB *partition= get_key_cache_partition_for_write(keycache,
file,
filepos,
part_map);
w_length = length;
set_if_smaller(w_length, keycache->key_cache_block_size - offset );
if (simple_key_cache_write(partition,
file, 0, filepos, level,
buff, w_length, block_length,
dont_write))
DBUG_RETURN(1);
filepos+= w_length;
buff+= w_length;
offset= 0;
} while ((length-= w_length));
DBUG_RETURN(0);
} | O3 | c | partitioned_key_cache_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movl %r8d, -0x2c(%rbp)
movq %rcx, %r15
movq %rdx, -0x40(%rbp)
movq %rdi, %r13
movl 0x10(%rbp), %r12d
movl 0x18(%rdi), %ecx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r8
movslq %esi, %rax
movq %rax, -0x38(%rbp)
movl 0x18(%r13), %ecx
movl 0x1c(%r13), %edi
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq -0x38(%rbp), %rsi
addq %rsi, %rax
xorl %edx, %edx
divq %rdi
movq %rdx, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0x40(%rbp), %rdx
orq %rax, (%rdx)
movq 0x8(%r13), %rax
movq (%rax,%rcx,8), %rdi
movl 0x18(%r13), %r14d
subl %r8d, %r14d
cmpl %r14d, %r12d
cmovbl %r12d, %r14d
movl 0x20(%rbp), %eax
movl %eax, 0x10(%rsp)
movl %r14d, (%rsp)
movq %r15, %rcx
movl -0x2c(%rbp), %r8d
movq %rbx, %r9
callq 0x992be
testl %eax, %eax
jne 0x9a9e8
movl %r14d, %eax
addq %rax, %rbx
addq %rax, %r15
xorl %r8d, %r8d
subl %r14d, %r12d
jne 0x9a973
jmp 0x9a9ee
movl $0x1, %r8d
movl %r8d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| partitioned_key_cache_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, r9
mov [rbp+var_2C], r8d
mov r15, rcx
mov [rbp+var_40], rdx
mov r13, rdi
mov r12d, [rbp+arg_0]
mov ecx, [rdi+18h]
mov rax, r15
xor edx, edx
div rcx
mov r8, rdx
movsxd rax, esi
mov [rbp+var_38], rax
loc_9A973:
mov ecx, [r13+18h]
mov edi, [r13+1Ch]
mov rax, r15
xor edx, edx
div rcx
mov rsi, [rbp+var_38]
add rax, rsi
xor edx, edx
div rdi
mov rcx, rdx
mov eax, 1
shl rax, cl
mov rdx, [rbp+var_40]
or [rdx], rax
mov rax, [r13+8]
mov rdi, [rax+rcx*8]
mov r14d, [r13+18h]
sub r14d, r8d
cmp r12d, r14d
cmovb r14d, r12d
mov eax, [rbp+arg_10]
mov [rsp+60h+var_50], eax
mov [rsp+60h+var_60], r14d
mov rcx, r15
mov r8d, [rbp+var_2C]
mov r9, rbx
call simple_key_cache_write
test eax, eax
jnz short loc_9A9E8
mov eax, r14d
add rbx, rax
add r15, rax
xor r8d, r8d
sub r12d, r14d
jnz short loc_9A973
jmp short loc_9A9EE
loc_9A9E8:
mov r8d, 1
loc_9A9EE:
mov eax, r8d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long partitioned_key_cache_write(
long long a1,
signed int a2,
_QWORD *a3,
unsigned long long a4,
int a5,
long long a6,
unsigned int a7,
int a8,
int a9)
{
unsigned long long v10; // r15
unsigned long long v12; // r8
unsigned long long v13; // rcx
unsigned int v14; // r14d
int v16; // [rsp+8h] [rbp-58h]
v10 = a4;
v12 = a4 % *(unsigned int *)(a1 + 24);
while ( 1 )
{
v13 = (a2 + v10 / *(unsigned int *)(a1 + 24)) % *(unsigned int *)(a1 + 28);
*a3 |= 1LL << v13;
v14 = *(_DWORD *)(a1 + 24) - v12;
if ( a7 < v14 )
v14 = a7;
if ( (unsigned int)simple_key_cache_write(
*(const __m128i **)(*(_QWORD *)(a1 + 8) + 8 * v13),
a2,
(long long)a3,
v10,
a5,
a6,
v14,
v16,
a9) )
break;
a6 += v14;
v10 += v14;
LODWORD(v12) = 0;
a7 -= v14;
if ( !a7 )
return (unsigned int)v12;
}
LODWORD(v12) = 1;
return (unsigned int)v12;
}
| partitioned_key_cache_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,R9
MOV dword ptr [RBP + -0x2c],R8D
MOV R15,RCX
MOV qword ptr [RBP + -0x40],RDX
MOV R13,RDI
MOV R12D,dword ptr [RBP + 0x10]
MOV ECX,dword ptr [RDI + 0x18]
MOV RAX,R15
XOR EDX,EDX
DIV RCX
MOV R8,RDX
MOVSXD RAX,ESI
MOV qword ptr [RBP + -0x38],RAX
LAB_0019a973:
MOV ECX,dword ptr [R13 + 0x18]
MOV EDI,dword ptr [R13 + 0x1c]
MOV RAX,R15
XOR EDX,EDX
DIV RCX
MOV RSI,qword ptr [RBP + -0x38]
ADD RAX,RSI
XOR EDX,EDX
DIV RDI
MOV RCX,RDX
MOV EAX,0x1
SHL RAX,CL
MOV RDX,qword ptr [RBP + -0x40]
OR qword ptr [RDX],RAX
MOV RAX,qword ptr [R13 + 0x8]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV R14D,dword ptr [R13 + 0x18]
SUB R14D,R8D
CMP R12D,R14D
CMOVC R14D,R12D
MOV EAX,dword ptr [RBP + 0x20]
MOV dword ptr [RSP + 0x10],EAX
MOV dword ptr [RSP],R14D
MOV RCX,R15
MOV R8D,dword ptr [RBP + -0x2c]
MOV R9,RBX
CALL 0x001992be
TEST EAX,EAX
JNZ 0x0019a9e8
MOV EAX,R14D
ADD RBX,RAX
ADD R15,RAX
XOR R8D,R8D
SUB R12D,R14D
JNZ 0x0019a973
JMP 0x0019a9ee
LAB_0019a9e8:
MOV R8D,0x1
LAB_0019a9ee:
MOV EAX,R8D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
partitioned_key_cache_write
(long param_1,int param_2,ulong *param_3,ulong param_4,int4 param_5,long param_6,
uint param_7)
{
int1 auVar1 [16];
int iVar2;
ulong uVar3;
uint uVar4;
uVar3 = param_4 % (ulong)*(uint *)(param_1 + 0x18);
while( true ) {
auVar1._8_8_ = 0;
auVar1._0_8_ = param_4 / *(uint *)(param_1 + 0x18) + (long)param_2;
auVar1 = auVar1 % ZEXT416(*(uint *)(param_1 + 0x1c));
*param_3 = *param_3 | 1L << (auVar1[0] & 0x3f);
uVar4 = *(int *)(param_1 + 0x18) - (int)uVar3;
if (param_7 < uVar4) {
uVar4 = param_7;
}
iVar2 = simple_key_cache_write
(*(int8 *)(*(long *)(param_1 + 8) + auVar1._0_8_ * 8),(long)param_2,
param_3,param_4,param_5,param_6,uVar4);
if (iVar2 != 0) break;
param_6 = param_6 + (ulong)uVar4;
param_4 = param_4 + uVar4;
uVar3 = 0;
param_7 = param_7 - uVar4;
if (param_7 == 0) {
return 0;
}
}
return 1;
}
| |
51,240 | js_map_finalizer | bluesky950520[P]quickjs/quickjs.c | static void js_map_finalizer(JSRuntime *rt, JSValue val)
{
JSObject *p;
JSMapState *s;
struct list_head *el, *el1;
JSMapRecord *mr;
p = JS_VALUE_GET_OBJ(val);
s = p->u.map_state;
if (s) {
/* if the object is deleted we are sure that no iterator is
using it */
list_for_each_safe(el, el1, &s->records) {
mr = list_entry(el, JSMapRecord, link);
if (!mr->empty) {
if (s->is_weak)
delete_map_weak_ref(rt, mr);
else
JS_FreeValueRT(rt, mr->key);
JS_FreeValueRT(rt, mr->value);
}
js_free_rt(rt, mr);
}
js_free_rt(rt, s->hash_table);
js_free_rt(rt, s);
}
} | O0 | c | js_map_finalizer:
subq $0x48, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x5a73a
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x5a718
movq 0x18(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x5a6ec
movq 0x20(%rsp), %rax
cmpl $0x0, (%rax)
je 0x5a6be
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5adc0
jmp 0x5a6d5
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
callq 0x22a50
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
callq 0x22a50
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x206a0
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x5a673
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x206a0
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x206a0
addq $0x48, %rsp
retq
nop
| js_map_finalizer:
sub rsp, 48h
mov [rsp+48h+var_10], rsi
mov [rsp+48h+var_8], rdx
mov [rsp+48h+var_18], rdi
mov rax, [rsp+48h+var_10]
mov [rsp+48h+var_20], rax
mov rax, [rsp+48h+var_20]
mov rax, [rax+30h]
mov [rsp+48h+var_28], rax
cmp [rsp+48h+var_28], 0
jz loc_5A73A
mov rax, [rsp+48h+var_28]
mov rax, [rax+10h]
mov [rsp+48h+var_30], rax
mov rax, [rsp+48h+var_30]
mov rax, [rax+8]
mov [rsp+48h+var_38], rax
loc_5A673:
mov rax, [rsp+48h+var_30]
mov rcx, [rsp+48h+var_28]
add rcx, 8
cmp rax, rcx
jz loc_5A718
mov rax, [rsp+48h+var_30]
add rax, 0FFFFFFFFFFFFFFF0h
mov [rsp+48h+var_40], rax
mov rax, [rsp+48h+var_40]
cmp dword ptr [rax+4], 0
jnz short loc_5A6EC
mov rax, [rsp+48h+var_28]
cmp dword ptr [rax], 0
jz short loc_5A6BE
mov rdi, [rsp+48h+var_18]
mov rsi, [rsp+48h+var_40]
call delete_map_weak_ref
jmp short loc_5A6D5
loc_5A6BE:
mov rdi, [rsp+48h+var_18]
mov rax, [rsp+48h+var_40]
mov rsi, [rax+30h]
mov rdx, [rax+38h]
call JS_FreeValueRT
loc_5A6D5:
mov rdi, [rsp+48h+var_18]
mov rax, [rsp+48h+var_40]
mov rsi, [rax+40h]
mov rdx, [rax+48h]
call JS_FreeValueRT
loc_5A6EC:
mov rdi, [rsp+48h+var_18]
mov rsi, [rsp+48h+var_40]
call js_free_rt
mov rax, [rsp+48h+var_38]
mov [rsp+48h+var_30], rax
mov rax, [rsp+48h+var_30]
mov rax, [rax+8]
mov [rsp+48h+var_38], rax
jmp loc_5A673
loc_5A718:
mov rdi, [rsp+48h+var_18]
mov rax, [rsp+48h+var_28]
mov rsi, [rax+20h]
call js_free_rt
mov rdi, [rsp+48h+var_18]
mov rsi, [rsp+48h+var_28]
call js_free_rt
loc_5A73A:
add rsp, 48h
retn
| void js_map_finalizer(long long a1, long long a2)
{
long long v2; // [rsp+8h] [rbp-40h]
long long v3; // [rsp+10h] [rbp-38h]
long long v4; // [rsp+18h] [rbp-30h]
long long v5; // [rsp+20h] [rbp-28h]
v5 = *(_QWORD *)(a2 + 48);
if ( v5 )
{
v4 = *(_QWORD *)(v5 + 16);
v3 = *(_QWORD *)(v4 + 8);
while ( v4 != v5 + 8 )
{
v2 = v4 - 16;
if ( !*(_DWORD *)(v4 - 16 + 4) )
{
if ( *(_DWORD *)v5 )
delete_map_weak_ref(a1, v2);
else
JS_FreeValueRT(a1, *(_DWORD **)(v2 + 48), *(_QWORD *)(v2 + 56));
JS_FreeValueRT(a1, *(_DWORD **)(v2 + 64), *(_QWORD *)(v2 + 72));
}
js_free_rt(a1, v2);
v4 = v3;
v3 = *(_QWORD *)(v3 + 8);
}
js_free_rt(a1, *(_QWORD *)(v5 + 32));
js_free_rt(a1, v5);
}
}
| js_map_finalizer:
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x30],RDI
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x20],RAX
CMP qword ptr [RSP + 0x20],0x0
JZ 0x0015a73a
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
LAB_0015a673:
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
ADD RCX,0x8
CMP RAX,RCX
JZ 0x0015a718
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,-0x10
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x4],0x0
JNZ 0x0015a6ec
MOV RAX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX],0x0
JZ 0x0015a6be
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0015adc0
JMP 0x0015a6d5
LAB_0015a6be:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX + 0x30]
MOV RDX,qword ptr [RAX + 0x38]
CALL 0x00122a50
LAB_0015a6d5:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX + 0x40]
MOV RDX,qword ptr [RAX + 0x48]
CALL 0x00122a50
LAB_0015a6ec:
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x001206a0
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0015a673
LAB_0015a718:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x20]
CALL 0x001206a0
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x001206a0
LAB_0015a73a:
ADD RSP,0x48
RET
|
void js_map_finalizer(int8 param_1,long param_2)
{
int *piVar1;
int *local_38;
int *local_30;
piVar1 = *(int **)(param_2 + 0x30);
if (piVar1 != (int *)0x0) {
local_30 = *(int **)(piVar1 + 4);
local_38 = *(int **)(local_30 + 2);
while (local_30 != piVar1 + 2) {
if (local_30[-3] == 0) {
if (*piVar1 == 0) {
JS_FreeValueRT(param_1,*(int8 *)(local_30 + 8),*(int8 *)(local_30 + 10));
}
else {
delete_map_weak_ref(param_1,local_30 + -4);
}
JS_FreeValueRT(param_1,*(int8 *)(local_30 + 0xc),*(int8 *)(local_30 + 0xe));
}
js_free_rt(param_1,local_30 + -4);
local_30 = local_38;
local_38 = *(int **)(local_38 + 2);
}
js_free_rt(param_1,*(int8 *)(piVar1 + 8));
js_free_rt(param_1,piVar1);
}
return;
}
| |
51,241 | js_map_finalizer | bluesky950520[P]quickjs/quickjs.c | static void js_map_finalizer(JSRuntime *rt, JSValue val)
{
JSObject *p;
JSMapState *s;
struct list_head *el, *el1;
JSMapRecord *mr;
p = JS_VALUE_GET_OBJ(val);
s = p->u.map_state;
if (s) {
/* if the object is deleted we are sure that no iterator is
using it */
list_for_each_safe(el, el1, &s->records) {
mr = list_entry(el, JSMapRecord, link);
if (!mr->empty) {
if (s->is_weak)
delete_map_weak_ref(rt, mr);
else
JS_FreeValueRT(rt, mr->key);
JS_FreeValueRT(rt, mr->value);
}
js_free_rt(rt, mr);
}
js_free_rt(rt, s->hash_table);
js_free_rt(rt, s);
}
} | O1 | c | js_map_finalizer:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rsi), %rbx
testq %rbx, %rbx
je 0x3a2d0
movq %rdi, %r14
leaq 0x8(%rbx), %r12
movq 0x10(%rbx), %rbp
cmpq %r12, %rbp
je 0x3a26d
movq 0x8(%rbp), %r13
leaq -0x10(%rbp), %r15
cmpl $0x0, -0xc(%rbp)
jne 0x3a240
cmpl $0x0, (%rbx)
je 0x3a220
movq %r14, %rdi
movq %r15, %rsi
callq 0x3a7e2
jmp 0x3a230
movq 0x20(%rbp), %rsi
movq 0x28(%rbp), %rdx
movq %r14, %rdi
callq 0x1ccb2
movq 0x30(%rbp), %rsi
movq 0x38(%rbp), %rdx
movq %r14, %rdi
callq 0x1ccb2
decq 0x28(%r14)
movq %r15, %rdi
callq *0x20(%r14)
movq 0x30(%r14), %rcx
movq 0x40(%r14), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%r14)
movq %r15, %rsi
callq *0x10(%r14)
movq %r13, %rbp
cmpq %r12, %r13
jne 0x3a200
movq 0x20(%rbx), %r15
testq %r15, %r15
je 0x3a29b
decq 0x28(%r14)
movq %r15, %rdi
callq *0x20(%r14)
movq 0x30(%r14), %rcx
movq 0x40(%r14), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%r14)
movq %r15, %rsi
callq *0x10(%r14)
decq 0x28(%r14)
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x10(%r14), %rcx
movq 0x30(%r14), %rdx
subq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x30(%r14)
movq 0x40(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_map_finalizer:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, [rsi+30h]
test rbx, rbx
jz loc_3A2D0
mov r14, rdi
lea r12, [rbx+8]
mov rbp, [rbx+10h]
cmp rbp, r12
jz short loc_3A26D
loc_3A200:
mov r13, [rbp+8]
lea r15, [rbp-10h]
cmp dword ptr [rbp-0Ch], 0
jnz short loc_3A240
cmp dword ptr [rbx], 0
jz short loc_3A220
mov rdi, r14
mov rsi, r15
call delete_map_weak_ref
jmp short loc_3A230
loc_3A220:
mov rsi, [rbp+20h]
mov rdx, [rbp+28h]
mov rdi, r14
call JS_FreeValueRT
loc_3A230:
mov rsi, [rbp+30h]
mov rdx, [rbp+38h]
mov rdi, r14
call JS_FreeValueRT
loc_3A240:
dec qword ptr [r14+28h]
mov rdi, r15
call qword ptr [r14+20h]
mov rcx, [r14+30h]
mov rdi, [r14+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [r14+30h], rcx
mov rsi, r15
call qword ptr [r14+10h]
mov rbp, r13
cmp r13, r12
jnz short loc_3A200
loc_3A26D:
mov r15, [rbx+20h]
test r15, r15
jz short loc_3A29B
dec qword ptr [r14+28h]
mov rdi, r15
call qword ptr [r14+20h]
mov rcx, [r14+30h]
mov rdi, [r14+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [r14+30h], rcx
mov rsi, r15
call qword ptr [r14+10h]
loc_3A29B:
dec qword ptr [r14+28h]
mov rdi, rbx
call qword ptr [r14+20h]
mov rcx, [r14+10h]
mov rdx, [r14+30h]
sub rdx, rax
add rdx, 0FFFFFFFFFFFFFFF8h
mov [r14+30h], rdx
mov rdi, [r14+40h]
mov rsi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rcx
loc_3A2D0:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_map_finalizer(long long a1, long long a2)
{
long long v2; // rbx
long long v4; // rbp
long long v5; // r13
long long v6; // rax
long long v7; // rdi
long long v8; // r15
long long v9; // rax
long long v10; // rdi
long long v11; // rax
long long ( *v12)(_QWORD, long long); // rcx
long long result; // rax
v2 = *(_QWORD *)(a2 + 48);
if ( v2 )
{
v4 = *(_QWORD *)(v2 + 16);
if ( v4 != v2 + 8 )
{
do
{
v5 = *(_QWORD *)(v4 + 8);
if ( !*(_DWORD *)(v4 - 12) )
{
if ( *(_DWORD *)v2 )
delete_map_weak_ref(a1, v4 - 16);
else
JS_FreeValueRT(a1, *(_DWORD **)(v4 + 32), *(_QWORD *)(v4 + 40));
JS_FreeValueRT(a1, *(_DWORD **)(v4 + 48), *(_QWORD *)(v4 + 56));
}
--*(_QWORD *)(a1 + 40);
v6 = (*(long long ( **)(long long))(a1 + 32))(v4 - 16);
v7 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v6 - 8;
(*(void ( **)(long long, long long))(a1 + 16))(v7, v4 - 16);
v4 = v5;
}
while ( v5 != v2 + 8 );
}
v8 = *(_QWORD *)(v2 + 32);
if ( v8 )
{
--*(_QWORD *)(a1 + 40);
v9 = (*(long long ( **)(long long))(a1 + 32))(v8);
v10 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v9 - 8;
(*(void ( **)(long long, long long))(a1 + 16))(v10, v8);
}
--*(_QWORD *)(a1 + 40);
v11 = (*(long long ( **)(long long))(a1 + 32))(v2);
v12 = *(long long ( **)(_QWORD, long long))(a1 + 16);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v11 - 8;
return v12(*(_QWORD *)(a1 + 64), v2);
}
return result;
}
| js_map_finalizer:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,qword ptr [RSI + 0x30]
TEST RBX,RBX
JZ 0x0013a2d0
MOV R14,RDI
LEA R12,[RBX + 0x8]
MOV RBP,qword ptr [RBX + 0x10]
CMP RBP,R12
JZ 0x0013a26d
LAB_0013a200:
MOV R13,qword ptr [RBP + 0x8]
LEA R15,[RBP + -0x10]
CMP dword ptr [RBP + -0xc],0x0
JNZ 0x0013a240
CMP dword ptr [RBX],0x0
JZ 0x0013a220
MOV RDI,R14
MOV RSI,R15
CALL 0x0013a7e2
JMP 0x0013a230
LAB_0013a220:
MOV RSI,qword ptr [RBP + 0x20]
MOV RDX,qword ptr [RBP + 0x28]
MOV RDI,R14
CALL 0x0011ccb2
LAB_0013a230:
MOV RSI,qword ptr [RBP + 0x30]
MOV RDX,qword ptr [RBP + 0x38]
MOV RDI,R14
CALL 0x0011ccb2
LAB_0013a240:
DEC qword ptr [R14 + 0x28]
MOV RDI,R15
CALL qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x30]
MOV RDI,qword ptr [R14 + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [R14 + 0x30],RCX
MOV RSI,R15
CALL qword ptr [R14 + 0x10]
MOV RBP,R13
CMP R13,R12
JNZ 0x0013a200
LAB_0013a26d:
MOV R15,qword ptr [RBX + 0x20]
TEST R15,R15
JZ 0x0013a29b
DEC qword ptr [R14 + 0x28]
MOV RDI,R15
CALL qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x30]
MOV RDI,qword ptr [R14 + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [R14 + 0x30],RCX
MOV RSI,R15
CALL qword ptr [R14 + 0x10]
LAB_0013a29b:
DEC qword ptr [R14 + 0x28]
MOV RDI,RBX
CALL qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [R14 + 0x30]
SUB RDX,RAX
ADD RDX,-0x8
MOV qword ptr [R14 + 0x30],RDX
MOV RDI,qword ptr [R14 + 0x40]
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RCX
LAB_0013a2d0:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void js_map_finalizer(long param_1,long param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
int *piVar4;
long lVar5;
long lVar6;
piVar2 = *(int **)(param_2 + 0x30);
if (piVar2 == (int *)0x0) {
return;
}
piVar4 = *(int **)(piVar2 + 4);
while (piVar4 != piVar2 + 2) {
piVar3 = *(int **)(piVar4 + 2);
piVar1 = piVar4 + -4;
if (piVar4[-3] == 0) {
if (*piVar2 == 0) {
JS_FreeValueRT(param_1,*(int8 *)(piVar4 + 8),*(int8 *)(piVar4 + 10));
}
else {
delete_map_weak_ref(param_1,piVar1);
}
JS_FreeValueRT(param_1,*(int8 *)(piVar4 + 0xc),*(int8 *)(piVar4 + 0xe));
}
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar5 = (**(code **)(param_1 + 0x20))(piVar1);
*(long *)(param_1 + 0x30) = (*(long *)(param_1 + 0x30) - lVar5) + -8;
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),piVar1);
piVar4 = piVar3;
}
lVar5 = *(long *)(piVar2 + 8);
if (lVar5 != 0) {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar6 = (**(code **)(param_1 + 0x20))(lVar5);
*(long *)(param_1 + 0x30) = (*(long *)(param_1 + 0x30) - lVar6) + -8;
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),lVar5);
}
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar5 = (**(code **)(param_1 + 0x20))(piVar2);
lVar5 = (*(long *)(param_1 + 0x30) - lVar5) + -8;
*(long *)(param_1 + 0x30) = lVar5;
/* WARNING: Could not recover jumptable at 0x0013a2ce. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x40),piVar2,lVar5,*(code **)(param_1 + 0x10));
return;
}
| |
51,242 | nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, parse_json(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)::json_error_locator>::get_msgpack_object(unsigned long) | monkey531[P]llama/common/./json.hpp | bool get_msgpack_object(const std::size_t len)
{
if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
{
return false;
}
string_t key;
for (std::size_t i = 0; i < len; ++i)
{
get();
if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
{
return false;
}
if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
{
return false;
}
key.clear();
}
return sax->end_object();
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, parse_json(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)::json_error_locator>::get_msgpack_object(unsigned long):
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rax), %rdi
movq 0x50(%rsp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x18ef03
jmp 0x18ef0d
movb $0x0, 0x67(%rsp)
jmp 0x18f046
leaq 0x30(%rsp), %rdi
callq 0x504a0
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x18f012
movq 0x10(%rsp), %rdi
callq 0x18b910
jmp 0x18ef3c
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x18f100
movb %al, 0xf(%rsp)
jmp 0x18ef51
movb 0xf(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0x18ef62
jmp 0x18ef89
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
leaq 0x30(%rsp), %rsi
callq *%rax
movb %al, 0xd(%rsp)
jmp 0x18ef7f
movb 0xd(%rsp), %al
xorb $-0x1, %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x18ef97
jmp 0x18efc6
movb $0x0, 0x67(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x18f03c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x510c0
jmp 0x18f051
movq 0x10(%rsp), %rdi
callq 0x18ab80
movb %al, 0xc(%rsp)
jmp 0x18efd6
movb 0xc(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x18efe6
jmp 0x18eff5
movb $0x0, 0x67(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x18f03c
leaq 0x30(%rsp), %rdi
callq 0x507b0
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x18ef20
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
movb %al, 0xb(%rsp)
jmp 0x18f02a
movb 0xb(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movl $0x1, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x510c0
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x50940
nopl (%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE18get_msgpack_objectEm:
sub rsp, 68h
mov [rsp+68h+var_10], rdi
mov [rsp+68h+var_18], rsi
mov rax, [rsp+68h+var_10]
mov [rsp+68h+var_58], rax
mov rdi, [rax+28h]
mov rsi, [rsp+68h+var_18]
mov rax, [rdi]
call qword ptr [rax+38h]
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_18EF03
jmp short loc_18EF0D
loc_18EF03:
mov [rsp+68h+var_1], 0
jmp loc_18F046
loc_18EF0D:
lea rdi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov [rsp+68h+var_40], 0
loc_18EF20:
mov rax, [rsp+68h+var_40]
cmp rax, [rsp+68h+var_18]
jnb loc_18F012
mov rdi, [rsp+68h+var_58]
call _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE3getEv; nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::get(void)
jmp short $+2
loc_18EF3C:
mov rdi, [rsp+68h+var_58]
lea rsi, [rsp+68h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE18get_msgpack_stringERSB_; nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::get_msgpack_string(std::string&)
mov [rsp+68h+var_59], al
jmp short $+2
loc_18EF51:
mov cl, [rsp+68h+var_59]
mov al, 1
test cl, 1
mov [rsp+68h+var_5A], al
jnz short loc_18EF62
jmp short loc_18EF89
loc_18EF62:
mov rax, [rsp+68h+var_58]
mov rdi, [rax+28h]
mov rax, [rdi]
mov rax, [rax+40h]
lea rsi, [rsp+68h+var_38]
call rax
mov [rsp+68h+var_5B], al
jmp short $+2
loc_18EF7F:
mov al, [rsp+68h+var_5B]
xor al, 0FFh
mov [rsp+68h+var_5A], al
loc_18EF89:
mov al, [rsp+68h+var_5A]
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_18EF97
jmp short loc_18EFC6
loc_18EF97:
mov [rsp+68h+var_1], 0
mov [rsp+68h+var_50], 1
jmp loc_18F03C
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_18F051
loc_18EFC6:
mov rdi, [rsp+68h+var_58]
call _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE22parse_msgpack_internalEv; nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::parse_msgpack_internal(void)
mov [rsp+68h+var_5C], al
jmp short $+2
loc_18EFD6:
mov al, [rsp+68h+var_5C]
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_18EFE6
jmp short loc_18EFF5
loc_18EFE6:
mov [rsp+68h+var_1], 0
mov [rsp+68h+var_50], 1
jmp short loc_18F03C
loc_18EFF5:
lea rdi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5clearEv; std::string::clear(void)
mov rax, [rsp+68h+var_40]
add rax, 1
mov [rsp+68h+var_40], rax
jmp loc_18EF20
loc_18F012:
mov rax, [rsp+68h+var_58]
mov rdi, [rax+28h]
mov rax, [rdi]
mov rax, [rax+48h]
call rax
mov [rsp+68h+var_5D], al
jmp short $+2
loc_18F02A:
mov al, [rsp+68h+var_5D]
and al, 1
mov [rsp+68h+var_1], al
mov [rsp+68h+var_50], 1
loc_18F03C:
lea rdi, [rsp+68h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_18F046:
mov al, [rsp+68h+var_1]
and al, 1
add rsp, 68h
retn
loc_18F051:
mov rdi, [rsp+arg_18]
call __Unwind_Resume
| char nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::get_msgpack_object(
long long a1,
unsigned long long a2)
{
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
char v7; // [rsp+Eh] [rbp-5Ah]
unsigned long long i; // [rsp+28h] [rbp-40h]
_BYTE v9[32]; // [rsp+30h] [rbp-38h] BYREF
unsigned long long v10; // [rsp+50h] [rbp-18h]
long long v11; // [rsp+58h] [rbp-10h]
char v12; // [rsp+67h] [rbp-1h]
v11 = a1;
v10 = a2;
if ( ((*(long long ( **)(_QWORD, unsigned long long))(**(_QWORD **)(a1 + 40) + 56LL))(*(_QWORD *)(a1 + 40), a2) & 1) != 0 )
{
std::string::basic_string(v9);
for ( i = 0LL; i < v10; ++i )
{
nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::get(a1);
v7 = 1;
if ( (nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::get_msgpack_string(
a1,
(unsigned int)v9,
v2,
v3,
v4,
v5) & 1) != 0 )
v7 = ~(*(unsigned __int8 ( **)(_QWORD, _BYTE *))(**(_QWORD **)(a1 + 40) + 64LL))(
*(_QWORD *)(a1 + 40),
v9);
if ( (v7 & 1) != 0 )
{
v12 = 0;
goto LABEL_13;
}
if ( (nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::parse_msgpack_internal(a1) & 1) == 0 )
{
v12 = 0;
goto LABEL_13;
}
std::string::clear(v9);
}
v12 = (*(long long ( **)(_QWORD))(**(_QWORD **)(a1 + 40) + 72LL))(*(_QWORD *)(a1 + 40)) & 1;
LABEL_13:
std::string::~string(v9);
}
else
{
v12 = 0;
}
return v12 & 1;
}
| __is_null_pointer<__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>>:
MOV qword ptr [RSP + -0x8],RDI
XOR EAX,EAX
AND AL,0x1
RET
|
/* bool __gnu_cxx::__is_null_pointer<__gnu_cxx::__normal_iterator<char*, std::__cxx11::string >
>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::string >) */
bool __gnu_cxx::__is_null_pointer<__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>>(void)
{
return false;
}
| |
51,243 | my_mb_wc_cp932 | eloqsql/strings/ctype-cp932.c | static int
my_mb_wc_cp932(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e){
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII: [00-7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
/* JIS-X-0201 Half width Katakana: [A1..DF] -> [U+FF61..U+FF9F] */
if (hi >= 0xA1 && hi <= 0xDF)
{
*pwc= cp932_to_unicode[hi];
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
/* JIS-X-0208-MS [81..9F,E0..FC][40..7E,80..FC] */
if (!(pwc[0]= cp932_to_unicode[(hi << 8) + s[1]]))
return (iscp932head(hi) && iscp932tail(s[1])) ? -2 : MY_CS_ILSEQ;
return 2;
} | O0 | c | my_mb_wc_cp932:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x3df9a
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x3e0f8
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x80, %eax
jge 0x3dfc2
movslq -0x2c(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3e0f8
cmpl $0xa1, -0x2c(%rbp)
jl 0x3dff8
cmpl $0xdf, -0x2c(%rbp)
jg 0x3dff8
movslq -0x2c(%rbp), %rcx
leaq 0x5f6b1(%rip), %rax # 0x9d690
movzwl (%rax,%rcx,2), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3e0f8
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x3e012
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x3e0f8
movl -0x2c(%rbp), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x5f664(%rip), %rax # 0x9d690
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x3e0f1
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
movl $0x81, %eax
cmpl %ecx, %eax
jg 0x3e05d
movl -0x2c(%rbp), %eax
movzbl %al, %eax
cmpl $0x9f, %eax
jle 0x3e084
movl -0x2c(%rbp), %eax
movzbl %al, %edx
xorl %eax, %eax
movl $0xe0, %ecx
cmpl %edx, %ecx
movb %al, -0x2d(%rbp)
jg 0x3e0dc
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0xfc, %ecx
movb %al, -0x2d(%rbp)
jg 0x3e0dc
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
jg 0x3e0a7
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x7e, %ecx
movb %al, -0x2e(%rbp)
jle 0x3e0d6
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %edx
xorl %eax, %eax
movl $0x80, %ecx
cmpl %edx, %ecx
movb %al, -0x2f(%rbp)
jg 0x3e0d0
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfc, %eax
setle %al
movb %al, -0x2f(%rbp)
movb -0x2f(%rbp), %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %dl
xorl %eax, %eax
movl $0xfffffffe, %ecx # imm = 0xFFFFFFFE
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x3e0f8
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| my_mb_wc_cp932:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_3DF9A
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_3E0F8
loc_3DF9A:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
cmp eax, 80h
jge short loc_3DFC2
movsxd rcx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_3E0F8
loc_3DFC2:
cmp [rbp+var_2C], 0A1h
jl short loc_3DFF8
cmp [rbp+var_2C], 0DFh
jg short loc_3DFF8
movsxd rcx, [rbp+var_2C]
lea rax, cp932_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_3E0F8
loc_3DFF8:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_3E012
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_3E0F8
loc_3E012:
mov eax, [rbp+var_2C]
shl eax, 8
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+1]
add eax, ecx
movsxd rcx, eax
lea rax, cp932_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jnz loc_3E0F1
mov eax, [rbp+var_2C]
movzx ecx, al
mov eax, 81h
cmp eax, ecx
jg short loc_3E05D
mov eax, [rbp+var_2C]
movzx eax, al
cmp eax, 9Fh
jle short loc_3E084
loc_3E05D:
mov eax, [rbp+var_2C]
movzx edx, al
xor eax, eax
mov ecx, 0E0h
cmp ecx, edx
mov [rbp+var_2D], al
jg short loc_3E0DC
mov eax, [rbp+var_2C]
movzx ecx, al
xor eax, eax
cmp ecx, 0FCh
mov [rbp+var_2D], al
jg short loc_3E0DC
loc_3E084:
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov eax, 40h ; '@'
cmp eax, ecx
jg short loc_3E0A7
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov al, 1
cmp ecx, 7Eh ; '~'
mov [rbp+var_2E], al
jle short loc_3E0D6
loc_3E0A7:
mov rax, [rbp+var_20]
movzx edx, byte ptr [rax+1]
xor eax, eax
mov ecx, 80h
cmp ecx, edx
mov [rbp+var_2F], al
jg short loc_3E0D0
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0FCh
setle al
mov [rbp+var_2F], al
loc_3E0D0:
mov al, [rbp+var_2F]
mov [rbp+var_2E], al
loc_3E0D6:
mov al, [rbp+var_2E]
mov [rbp+var_2D], al
loc_3E0DC:
mov dl, [rbp+var_2D]
xor eax, eax
mov ecx, 0FFFFFFFEh
test dl, 1
cmovnz eax, ecx
mov [rbp+var_4], eax
jmp short loc_3E0F8
loc_3E0F1:
mov [rbp+var_4], 2
loc_3E0F8:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_mb_wc_cp932(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long v4; // rax
unsigned int v5; // eax
bool v7; // [rsp+1h] [rbp-2Fh]
char v8; // [rsp+2h] [rbp-2Eh]
char v9; // [rsp+3h] [rbp-2Dh]
unsigned int v10; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
v10 = *a3;
if ( v10 >= 0x80 )
{
if ( *a3 < 0xA1u || *a3 > 0xDFu )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v4 = cp932_to_unicode[a3[1] + (v10 << 8)];
*a2 = v4;
if ( v4 )
{
return 2;
}
else
{
if ( (unsigned __int8)v10 >= 0x81u && (unsigned __int8)v10 <= 0x9Fu
|| (v9 = 0, (unsigned __int8)v10 >= 0xE0u) && (v9 = 0, (unsigned __int8)v10 <= 0xFCu) )
{
if ( a3[1] < 0x40u || (v8 = 1, a3[1] > 0x7Eu) )
{
v7 = 0;
if ( a3[1] >= 0x80u )
v7 = a3[1] <= 0xFCu;
v8 = v7;
}
v9 = v8;
}
v5 = 0;
if ( (v9 & 1) != 0 )
return (unsigned int)-2;
return v5;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
*a2 = cp932_to_unicode[*a3];
return 1;
}
}
else
{
*a2 = *a3;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_mb_wc_cp932:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0013df9a
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0013e0f8
LAB_0013df9a:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x80
JGE 0x0013dfc2
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013e0f8
LAB_0013dfc2:
CMP dword ptr [RBP + -0x2c],0xa1
JL 0x0013dff8
CMP dword ptr [RBP + -0x2c],0xdf
JG 0x0013dff8
MOVSXD RCX,dword ptr [RBP + -0x2c]
LEA RAX,[0x19d690]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013e0f8
LAB_0013dff8:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0013e012
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0013e0f8
LAB_0013e012:
MOV EAX,dword ptr [RBP + -0x2c]
SHL EAX,0x8
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x1]
ADD EAX,ECX
MOVSXD RCX,EAX
LEA RAX,[0x19d690]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x0013e0f1
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX ECX,AL
MOV EAX,0x81
CMP EAX,ECX
JG 0x0013e05d
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX EAX,AL
CMP EAX,0x9f
JLE 0x0013e084
LAB_0013e05d:
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX EDX,AL
XOR EAX,EAX
MOV ECX,0xe0
CMP ECX,EDX
MOV byte ptr [RBP + -0x2d],AL
JG 0x0013e0dc
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX ECX,AL
XOR EAX,EAX
CMP ECX,0xfc
MOV byte ptr [RBP + -0x2d],AL
JG 0x0013e0dc
LAB_0013e084:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x40
CMP EAX,ECX
JG 0x0013e0a7
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV AL,0x1
CMP ECX,0x7e
MOV byte ptr [RBP + -0x2e],AL
JLE 0x0013e0d6
LAB_0013e0a7:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EDX,byte ptr [RAX + 0x1]
XOR EAX,EAX
MOV ECX,0x80
CMP ECX,EDX
MOV byte ptr [RBP + -0x2f],AL
JG 0x0013e0d0
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xfc
SETLE AL
MOV byte ptr [RBP + -0x2f],AL
LAB_0013e0d0:
MOV AL,byte ptr [RBP + -0x2f]
MOV byte ptr [RBP + -0x2e],AL
LAB_0013e0d6:
MOV AL,byte ptr [RBP + -0x2e]
MOV byte ptr [RBP + -0x2d],AL
LAB_0013e0dc:
MOV DL,byte ptr [RBP + -0x2d]
XOR EAX,EAX
MOV ECX,0xfffffffe
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013e0f8
LAB_0013e0f1:
MOV dword ptr [RBP + -0x4],0x2
LAB_0013e0f8:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_cp932(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
ushort uVar1;
bool bVar2;
uint uVar3;
int4 local_c;
if (param_3 < param_4) {
uVar3 = (uint)*param_3;
if (uVar3 < 0x80) {
*param_2 = (long)(int)uVar3;
local_c = 1;
}
else if ((uVar3 < 0xa1) || (0xdf < uVar3)) {
if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
uVar1 = *(ushort *)(cp932_to_unicode + (long)(int)(uVar3 * 0x100 + (uint)param_3[1]) * 2);
*param_2 = (ulong)uVar1;
if ((ulong)uVar1 == 0) {
if ((((0x80 < uVar3) && (uVar3 < 0xa0)) ||
((bVar2 = false, 0xdf < uVar3 && (bVar2 = false, uVar3 < 0xfd)))) &&
(((param_3[1] < 0x40 || (bVar2 = true, 0x7e < param_3[1])) &&
(bVar2 = false, 0x7f < param_3[1])))) {
bVar2 = param_3[1] < 0xfd;
}
local_c = 0;
if (bVar2) {
local_c = 0xfffffffe;
}
}
else {
local_c = 2;
}
}
}
else {
*param_2 = (ulong)*(ushort *)(cp932_to_unicode + (long)(int)uVar3 * 2);
local_c = 1;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
51,244 | write_index | eloqsql/storage/maria/ma_sort.c | static int write_index(MARIA_SORT_PARAM *info, register uchar **sort_keys,
register ha_keys count)
{
DBUG_ENTER("write_index");
my_qsort2((uchar*) sort_keys,(size_t) count,sizeof(uchar*),
(qsort2_cmp) info->key_cmp,info);
while (count--)
{
if ((*info->key_write)(info, *sort_keys++))
DBUG_RETURN(-1); /* purecov: inspected */
}
if (info->sort_info->param->max_stage != 1) /* If not parallel */
_ma_report_progress(info->sort_info->param, 1, 1);
DBUG_RETURN(0);
} | O3 | c | write_index:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x668(%rdi), %rcx
movl $0x8, %edx
movq %rsi, %rdi
movq %rbx, %rsi
movq %r14, %r8
callq 0xb857c
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x8337c
movq (%r15,%r12,8), %rsi
movq %r14, %rdi
callq *0x678(%r14)
incq %r12
testl %eax, %eax
je 0x8335b
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
jmp 0x833a4
movq 0x380(%r14), %rax
movq 0x90(%rax), %rdi
xorl %ebx, %ebx
cmpl $0x1, 0x20cc8(%rdi)
je 0x833a4
movl $0x1, %esi
movl $0x1, %edx
callq 0x32db7
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| write_index:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdx
mov r15, rsi
mov r14, rdi
mov rcx, [rdi+668h]
mov edx, 8
mov rdi, rsi
mov rsi, rbx
mov r8, r14
call my_qsort2
xor r12d, r12d
loc_8335B:
cmp rbx, r12
jz short loc_8337C
mov rsi, [r15+r12*8]
mov rdi, r14
call qword ptr [r14+678h]
inc r12
test eax, eax
jz short loc_8335B
mov ebx, 0FFFFFFFFh
jmp short loc_833A4
loc_8337C:
mov rax, [r14+380h]
mov rdi, [rax+90h]
xor ebx, ebx
cmp dword ptr [rdi+20CC8h], 1
jz short loc_833A4
mov esi, 1
mov edx, 1
call _ma_report_progress
loc_833A4:
mov eax, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long write_index(long long a1, long long a2, long long a3)
{
long long v4; // r12
unsigned int v6; // ebx
my_qsort2(a2, a3, 8LL, *(_QWORD *)(a1 + 1640), a1);
v4 = 0LL;
while ( a3 != v4 )
{
if ( (*(unsigned int ( **)(long long, _QWORD))(a1 + 1656))(a1, *(_QWORD *)(a2 + 8 * v4++)) )
return (unsigned int)-1;
}
v6 = 0;
if ( *(_DWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 896) + 144LL) + 134344LL) != 1 )
ma_report_progress();
return v6;
}
| write_index:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
MOV RCX,qword ptr [RDI + 0x668]
MOV EDX,0x8
MOV RDI,RSI
MOV RSI,RBX
MOV R8,R14
CALL 0x001b857c
XOR R12D,R12D
LAB_0018335b:
CMP RBX,R12
JZ 0x0018337c
MOV RSI,qword ptr [R15 + R12*0x8]
MOV RDI,R14
CALL qword ptr [R14 + 0x678]
INC R12
TEST EAX,EAX
JZ 0x0018335b
MOV EBX,0xffffffff
JMP 0x001833a4
LAB_0018337c:
MOV RAX,qword ptr [R14 + 0x380]
MOV RDI,qword ptr [RAX + 0x90]
XOR EBX,EBX
CMP dword ptr [RDI + 0x20cc8],0x1
JZ 0x001833a4
MOV ESI,0x1
MOV EDX,0x1
CALL 0x00132db7
LAB_001833a4:
MOV EAX,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 write_index(long param_1,long param_2,long param_3)
{
int iVar1;
long lVar2;
my_qsort2(param_2,param_3,8,*(int8 *)(param_1 + 0x668),param_1);
lVar2 = 0;
do {
if (param_3 == lVar2) {
lVar2 = *(long *)(*(long *)(param_1 + 0x380) + 0x90);
if (*(int *)(lVar2 + 0x20cc8) == 1) {
return 0;
}
_ma_report_progress(lVar2,1,1);
return 0;
}
iVar1 = (**(code **)(param_1 + 0x678))(param_1,*(int8 *)(param_2 + lVar2 * 8));
lVar2 = lVar2 + 1;
} while (iVar1 == 0);
return 0xffffffff;
}
| |
51,245 | js_string_CreateHTML | bluesky950520[P]quickjs/quickjs.c | static JSValue js_string_CreateHTML(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
JSValue str;
const JSString *p;
StringBuffer b_s, *b = &b_s;
static struct { const char *tag, *attr; } const defs[] = {
{ "a", "name" }, { "big", NULL }, { "blink", NULL }, { "b", NULL },
{ "tt", NULL }, { "font", "color" }, { "font", "size" }, { "i", NULL },
{ "a", "href" }, { "small", NULL }, { "strike", NULL },
{ "sub", NULL }, { "sup", NULL },
};
str = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(str))
return JS_EXCEPTION;
string_buffer_init(ctx, b, 7);
string_buffer_putc8(b, '<');
string_buffer_puts8(b, defs[magic].tag);
if (defs[magic].attr) {
// r += " " + attr + "=\"" + value + "\"";
JSValue value;
int i;
string_buffer_putc8(b, ' ');
string_buffer_puts8(b, defs[magic].attr);
string_buffer_puts8(b, "=\"");
value = JS_ToStringCheckObject(ctx, argv[0]);
if (JS_IsException(value)) {
JS_FreeValue(ctx, str);
string_buffer_free(b);
return JS_EXCEPTION;
}
p = JS_VALUE_GET_STRING(value);
for (i = 0; i < p->len; i++) {
int c = string_get(p, i);
if (c == '"') {
string_buffer_puts8(b, """);
} else {
string_buffer_putc16(b, c);
}
}
JS_FreeValue(ctx, value);
string_buffer_putc8(b, '\"');
}
// return r + ">" + str + "</" + tag + ">";
string_buffer_putc8(b, '>');
string_buffer_concat_value_free(b, str);
string_buffer_puts8(b, "</");
string_buffer_puts8(b, defs[magic].tag);
string_buffer_putc8(b, '>');
return string_buffer_end(b);
} | O2 | c | js_string_CreateHTML:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r14d
movq %r8, %rbp
movq %rdi, %r15
callq 0x3a290
movq %rdx, %rbx
pushq $0x6
popq %r13
cmpl $0x6, %ebx
je 0x69528
movq %rax, (%rsp)
leaq 0x18(%rsp), %r12
pushq $0x7
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2e042
pushq $0x3c
popq %rsi
movq %r12, %rdi
callq 0x41425
movslq %r14d, %rax
shlq $0x4, %rax
leaq 0x4fe8f(%rip), %rcx # 0xb9340
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %r14
movq %r12, %rdi
movq %rsi, 0x10(%rsp)
callq 0x41ca2
testq %r14, %r14
je 0x695a4
leaq 0x18(%rsp), %r12
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x41425
movq %r12, %rdi
movq %r14, %rsi
callq 0x41ca2
leaq 0x1fc91(%rip), %rsi # 0x89183
movq %r12, %rdi
callq 0x41ca2
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %r15, %rdi
callq 0x3a290
cmpl $0x6, %edx
jne 0x69531
movq %r15, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0x1801e
leaq 0x18(%rsp), %rdi
callq 0x2ef01
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x69605
movq %rax, %rbp
movq %rdx, 0x8(%rsp)
xorl %r12d, %r12d
leaq 0x1fc43(%rip), %r13 # 0x89186
leaq 0x18(%rsp), %r14
movq 0x4(%rbp), %rax
movl %eax, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
cmpq %rcx, %r12
jae 0x69587
testl %eax, %eax
js 0x69565
movzbl 0x18(%rbp,%r12), %esi
jmp 0x6956b
movzwl 0x18(%rbp,%r12,2), %esi
movq %r14, %rdi
cmpl $0x22, %esi
jne 0x6957d
movq %r13, %rsi
callq 0x41ca2
jmp 0x69582
callq 0x3dcf6
incq %r12
jmp 0x69548
movq %r15, %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
callq 0x1801e
leaq 0x18(%rsp), %rdi
pushq $0x22
popq %rsi
callq 0x41425
leaq 0x18(%rsp), %r14
pushq $0x3e
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x41425
movq %r14, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0x41476
leaq 0x1fbc1(%rip), %rsi # 0x8918d
movq %r14, %rdi
callq 0x41ca2
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x41ca2
movq %r14, %rdi
movl %ebp, %esi
callq 0x41425
movq %r14, %rdi
callq 0x2cad4
movq %rdx, %r13
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %eax
orq %rcx, %rax
movq %r13, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_string_CreateHTML:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r14d, r9d
mov rbp, r8
mov r15, rdi
call JS_ToStringCheckObject
mov rbx, rdx
push 6
pop r13
cmp ebx, 6
jz loc_69528
mov [rsp+68h+var_68], rax
lea r12, [rsp+68h+var_50]
push 7
pop rdx
mov rdi, r15
mov rsi, r12
call string_buffer_init
push 3Ch ; '<'
pop rsi
mov rdi, r12
call string_buffer_putc8
movsxd rax, r14d
shl rax, 4
lea rcx, js_string_CreateHTML_defs
mov rsi, [rax+rcx]
mov r14, [rax+rcx+8]
mov rdi, r12
mov [rsp+68h+var_58], rsi
call string_buffer_puts8
test r14, r14
jz loc_695A4
lea r12, [rsp+68h+var_50]
push 20h ; ' '
pop rsi
mov rdi, r12
call string_buffer_putc8
mov rdi, r12
mov rsi, r14
call string_buffer_puts8
lea rsi, asc_89183; "=\""
mov rdi, r12
call string_buffer_puts8
mov rsi, [rbp+0]
mov rdx, [rbp+8]
mov rdi, r15
call JS_ToStringCheckObject
cmp edx, 6
jnz short loc_69531
mov rdi, r15
mov rsi, [rsp+68h+var_68]
mov rdx, rbx
call JS_FreeValue
lea rdi, [rsp+68h+var_50]
call string_buffer_free
loc_69528:
xor eax, eax
xor ecx, ecx
jmp loc_69605
loc_69531:
mov rbp, rax
mov [rsp+68h+var_60], rdx
xor r12d, r12d
lea r13, aQuot; """
lea r14, [rsp+68h+var_50]
loc_69548:
mov rax, [rbp+4]
mov ecx, eax
and ecx, 7FFFFFFFh
cmp r12, rcx
jnb short loc_69587
test eax, eax
js short loc_69565
movzx esi, byte ptr [rbp+r12+18h]
jmp short loc_6956B
loc_69565:
movzx esi, word ptr [rbp+r12*2+18h]
loc_6956B:
mov rdi, r14
cmp esi, 22h ; '"'
jnz short loc_6957D
mov rsi, r13
call string_buffer_puts8
jmp short loc_69582
loc_6957D:
call string_buffer_putc16
loc_69582:
inc r12
jmp short loc_69548
loc_69587:
mov rdi, r15
mov rsi, rbp
mov rdx, [rsp+68h+var_60]
call JS_FreeValue
lea rdi, [rsp+68h+var_50]
push 22h ; '"'
pop rsi
call string_buffer_putc8
loc_695A4:
lea r14, [rsp+68h+var_50]
push 3Eh ; '>'
pop rbp
mov rdi, r14
mov esi, ebp
call string_buffer_putc8
mov rdi, r14
mov rsi, [rsp+68h+var_68]
mov rdx, rbx
call string_buffer_concat_value_free
lea rsi, asc_8918D; "</"
mov rdi, r14
call string_buffer_puts8
mov rdi, r14
mov rsi, [rsp+68h+var_58]
call string_buffer_puts8
mov rdi, r14
mov esi, ebp
call string_buffer_putc8
mov rdi, r14
call string_buffer_end
mov r13, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov eax, eax
loc_69605:
or rax, rcx
mov rdx, r13
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long js_string_CreateHTML(
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)
{
int v14; // r14d
long long v16; // rax
long long v17; // rdx
long long v18; // rbx
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
long long v25; // rax
long long v26; // r14
long long v27; // rdx
long long v28; // rcx
long long v29; // r8
long long v30; // r9
__m128 v31; // xmm4
__m128 v32; // xmm5
long long v33; // rcx
long long v34; // r8
long long v35; // r9
__m128 v36; // xmm4
__m128 v37; // xmm5
long long v38; // rax
long long v39; // rdx
long long v40; // rax
unsigned long long v41; // rcx
long long v42; // rbp
unsigned long long i; // r12
long long v44; // rax
unsigned int v45; // esi
long long v46; // rdx
long long v47; // rcx
long long v48; // r8
long long v49; // r9
__m128 v50; // xmm4
__m128 v51; // xmm5
long long v52; // rdx
long long v53; // rcx
long long v54; // r8
long long v55; // r9
__m128 v56; // xmm4
__m128 v57; // xmm5
long long v59; // [rsp+0h] [rbp-68h]
long long v60; // [rsp+8h] [rbp-60h]
long long v61; // [rsp+10h] [rbp-58h]
long long v62[10]; // [rsp+18h] [rbp-50h] BYREF
v14 = a6;
v16 = JS_ToStringCheckObject(a1, a2, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v18 = v17;
if ( (_DWORD)v17 == 6 )
goto LABEL_5;
v59 = v16;
string_buffer_init(a1, (long long)v62, 7u);
string_buffer_putc8((long long)v62, 0x3Cu, a7, a8, a9, a10, v23, v24, a13, a14, v19, v20, v21, v22);
v25 = 16LL * v14;
v26 = *(long long *)((char *)&js_string_CreateHTML_defs + v25 + 8);
v61 = *(long long *)((char *)&js_string_CreateHTML_defs + v25);
string_buffer_puts8((long long)v62, v61);
if ( !v26 )
{
LABEL_16:
string_buffer_putc8((long long)v62, 0x3Eu, a7, a8, a9, a10, v31, v32, a13, a14, v27, v28, v29, v30);
string_buffer_concat_value_free((long long)v62, v59, v18);
string_buffer_puts8((long long)v62, (long long)"</");
string_buffer_puts8((long long)v62, v61);
string_buffer_putc8((long long)v62, 0x3Eu, a7, a8, a9, a10, v56, v57, a13, a14, v52, v53, v54, v55);
v40 = string_buffer_end(v62);
v41 = v40 & 0xFFFFFFFF00000000LL;
v40 = (unsigned int)v40;
return v41 | v40;
}
string_buffer_putc8((long long)v62, 0x20u, a7, a8, a9, a10, v31, v32, a13, a14, v27, v28, v29, v30);
string_buffer_puts8((long long)v62, v26);
string_buffer_puts8((long long)v62, (long long)"=\"");
v38 = JS_ToStringCheckObject(a1, *a5, a5[1], v33, v34, v35, a7, a8, a9, a10, v36, v37, a13, a14);
if ( (_DWORD)v39 != 6 )
{
v42 = v38;
v60 = v39;
for ( i = 0LL; ; ++i )
{
v44 = *(_QWORD *)(v42 + 4);
if ( i >= ((unsigned int)v44 & 0x7FFFFFFF) )
break;
if ( (int)v44 < 0 )
v45 = *(unsigned __int16 *)(v42 + 2 * i + 24);
else
v45 = *(unsigned __int8 *)(v42 + i + 24);
if ( v45 == 34 )
string_buffer_puts8((long long)v62, (long long)""");
else
string_buffer_putc16((long long)v62, v45);
}
JS_FreeValue(a1, v42, v60);
string_buffer_putc8((long long)v62, 0x22u, a7, a8, a9, a10, v50, v51, a13, a14, v46, v47, v48, v49);
goto LABEL_16;
}
JS_FreeValue(a1, v59, v18);
string_buffer_free(v62);
LABEL_5:
v40 = 0LL;
v41 = 0LL;
return v41 | v40;
}
| js_string_CreateHTML:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14D,R9D
MOV RBP,R8
MOV R15,RDI
CALL 0x0013a290
MOV RBX,RDX
PUSH 0x6
POP R13
CMP EBX,0x6
JZ 0x00169528
MOV qword ptr [RSP],RAX
LEA R12,[RSP + 0x18]
PUSH 0x7
POP RDX
MOV RDI,R15
MOV RSI,R12
CALL 0x0012e042
PUSH 0x3c
POP RSI
MOV RDI,R12
CALL 0x00141425
MOVSXD RAX,R14D
SHL RAX,0x4
LEA RCX,[0x1b9340]
MOV RSI,qword ptr [RAX + RCX*0x1]
MOV R14,qword ptr [RAX + RCX*0x1 + 0x8]
MOV RDI,R12
MOV qword ptr [RSP + 0x10],RSI
CALL 0x00141ca2
TEST R14,R14
JZ 0x001695a4
LEA R12,[RSP + 0x18]
PUSH 0x20
POP RSI
MOV RDI,R12
CALL 0x00141425
MOV RDI,R12
MOV RSI,R14
CALL 0x00141ca2
LEA RSI,[0x189183]
MOV RDI,R12
CALL 0x00141ca2
MOV RSI,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
MOV RDI,R15
CALL 0x0013a290
CMP EDX,0x6
JNZ 0x00169531
MOV RDI,R15
MOV RSI,qword ptr [RSP]
MOV RDX,RBX
CALL 0x0011801e
LEA RDI,[RSP + 0x18]
CALL 0x0012ef01
LAB_00169528:
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00169605
LAB_00169531:
MOV RBP,RAX
MOV qword ptr [RSP + 0x8],RDX
XOR R12D,R12D
LEA R13,[0x189186]
LEA R14,[RSP + 0x18]
LAB_00169548:
MOV RAX,qword ptr [RBP + 0x4]
MOV ECX,EAX
AND ECX,0x7fffffff
CMP R12,RCX
JNC 0x00169587
TEST EAX,EAX
JS 0x00169565
MOVZX ESI,byte ptr [RBP + R12*0x1 + 0x18]
JMP 0x0016956b
LAB_00169565:
MOVZX ESI,word ptr [RBP + R12*0x2 + 0x18]
LAB_0016956b:
MOV RDI,R14
CMP ESI,0x22
JNZ 0x0016957d
MOV RSI,R13
CALL 0x00141ca2
JMP 0x00169582
LAB_0016957d:
CALL 0x0013dcf6
LAB_00169582:
INC R12
JMP 0x00169548
LAB_00169587:
MOV RDI,R15
MOV RSI,RBP
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x0011801e
LEA RDI,[RSP + 0x18]
PUSH 0x22
POP RSI
CALL 0x00141425
LAB_001695a4:
LEA R14,[RSP + 0x18]
PUSH 0x3e
POP RBP
MOV RDI,R14
MOV ESI,EBP
CALL 0x00141425
MOV RDI,R14
MOV RSI,qword ptr [RSP]
MOV RDX,RBX
CALL 0x00141476
LEA RSI,[0x18918d]
MOV RDI,R14
CALL 0x00141ca2
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x00141ca2
MOV RDI,R14
MOV ESI,EBP
CALL 0x00141425
MOV RDI,R14
CALL 0x0012cad4
MOV R13,RDX
MOV RCX,-0x100000000
AND RCX,RAX
MOV EAX,EAX
LAB_00169605:
OR RAX,RCX
MOV RDX,R13
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] js_string_CreateHTML(int8 param_1)
{
int8 uVar1;
uint uVar2;
long lVar3;
ulong uVar4;
ushort uVar5;
int8 *in_R8;
int in_R9D;
ulong uVar6;
int8 uVar7;
int1 auVar8 [16];
int1 auVar9 [16];
int1 local_50 [32];
auVar8 = JS_ToStringCheckObject();
uVar7 = 6;
if (auVar8._8_4_ == 6) {
LAB_00169528:
uVar6 = 0;
uVar4 = 0;
}
else {
string_buffer_init(param_1,local_50,7);
string_buffer_putc8(local_50,0x3c);
uVar1 = *(int8 *)(js_string_CreateHTML_defs + (long)in_R9D * 0x10);
lVar3 = *(long *)(js_string_CreateHTML_defs + (long)in_R9D * 0x10 + 8);
string_buffer_puts8(local_50);
if (lVar3 != 0) {
string_buffer_putc8(local_50,0x20);
string_buffer_puts8(local_50,lVar3);
string_buffer_puts8(local_50,&DAT_00189183);
auVar9 = JS_ToStringCheckObject(param_1,*in_R8,in_R8[1]);
lVar3 = auVar9._0_8_;
if (auVar9._8_4_ == 6) {
JS_FreeValue(param_1,auVar8._0_8_,auVar8._8_8_);
string_buffer_free(local_50);
goto LAB_00169528;
}
uVar6 = 0;
while( true ) {
uVar2 = (uint)*(int8 *)(lVar3 + 4);
if ((uVar2 & 0x7fffffff) <= uVar6) break;
if ((int)uVar2 < 0) {
uVar5 = *(ushort *)(lVar3 + 0x18 + uVar6 * 2);
}
else {
uVar5 = (ushort)*(byte *)(lVar3 + 0x18 + uVar6);
}
if (uVar5 == 0x22) {
string_buffer_puts8(local_50,""");
}
else {
string_buffer_putc16(local_50);
}
uVar6 = uVar6 + 1;
}
JS_FreeValue(param_1,lVar3,auVar9._8_8_);
string_buffer_putc8(local_50,0x22);
}
string_buffer_putc8(local_50,0x3e);
string_buffer_concat_value_free(local_50,auVar8._0_8_,auVar8._8_8_);
string_buffer_puts8(local_50,&DAT_0018918d);
string_buffer_puts8(local_50,uVar1);
string_buffer_putc8(local_50,0x3e);
auVar8 = string_buffer_end(local_50);
uVar7 = auVar8._8_8_;
uVar4 = auVar8._0_8_ & 0xffffffff00000000;
uVar6 = auVar8._0_8_ & 0xffffffff;
}
auVar8._0_8_ = uVar6 | uVar4;
auVar8._8_8_ = uVar7;
return auVar8;
}
| |
51,246 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double) | monkey531[P]llama/common/./json.hpp | boundaries compute_boundaries(FloatType value)
{
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// Convert the IEEE representation into a diyfp.
//
// If v is denormal:
// value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1))
// If v is normalized:
// value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
static_assert(std::numeric_limits<FloatType>::is_iec559,
"internal error: dtoa_short requires an IEEE-754 floating-point implementation");
constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
constexpr int kMinExp = 1 - kBias;
constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
const std::uint64_t E = bits >> (kPrecision - 1);
const std::uint64_t F = bits & (kHiddenBit - 1);
const bool is_denormal = E == 0;
const diyfp v = is_denormal
? diyfp(F, kMinExp)
: diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
// Compute the boundaries m- and m+ of the floating-point value
// v = f * 2^e.
//
// Determine v- and v+, the floating-point predecessor and successor if v,
// respectively.
//
// v- = v - 2^e if f != 2^(p-1) or e == e_min (A)
// = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B)
//
// v+ = v + 2^e
//
// Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
// between m- and m+ round to v, regardless of how the input rounding
// algorithm breaks ties.
//
// ---+-------------+-------------+-------------+-------------+--- (A)
// v- m- v m+ v+
//
// -----------------+------+------+-------------+-------------+--- (B)
// v- m- v m+ v+
const bool lower_boundary_is_closer = F == 0 && E > 1;
const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
const diyfp m_minus = lower_boundary_is_closer
? diyfp(4 * v.f - 1, v.e - 2) // (B)
: diyfp(2 * v.f - 1, v.e - 1); // (A)
// Determine the normalized w+ = m+.
const diyfp w_plus = diyfp::normalize(m_plus);
// Determine w- = m- such that e_(w-) = e_(w+).
const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
return {diyfp::normalize(v), w_minus, w_plus};
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %xmm0, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
jge 0x765a6
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x765c2
movq %rdi, %rbx
movabsq $0x10000000000000, %rcx # imm = 0x10000000000000
decq %rcx
andq %rax, %rcx
movq %rax, %rdx
shrq $0x34, %rdx
movq %rcx, %r14
btsq $0x34, %r14
leal -0x433(%rdx), %esi
testq %rdx, %rdx
cmoveq %rcx, %r14
movl $0xfffffbce, %r15d # imm = 0xFFFFFBCE
cmovnel %esi, %r15d
testq %rcx, %rcx
sete %cl
shrq $0x35, %rax
setne %al
leaq (%r14,%r14), %rdx
leal -0x1(%r15), %esi
leaq (,%r14,4), %rdi
testb %cl, %al
cmoveq %rdx, %rdi
leal -0x2(%r15), %eax
cmovel %esi, %eax
decq %rdi
leaq 0x8(%rsp), %r12
movq %rdi, (%r12)
movl %eax, 0x8(%r12)
leaq 0x1(,%r14,2), %rdi
callq 0x76714
movq %rax, (%rsp)
movl %edx, %ebp
movq %r12, %rdi
movl %edx, %esi
callq 0x76756
movq %rax, %r12
movl %edx, %r13d
movq %r14, %rdi
movl %r15d, %esi
callq 0x76714
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movl %r13d, 0x18(%rbx)
movq (%rsp), %rax
movq %rax, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd57e1(%rip), %rdi # 0x14bd8e
leaq 0xd5826(%rip), %rdx # 0x14bdda
leaq 0xd74c0(%rip), %rcx # 0x14da7b
movl $0x42cb, %esi # imm = 0x42CB
jmp 0x765dc
leaq 0xd57c5(%rip), %rdi # 0x14bd8e
leaq 0xd580a(%rip), %rdx # 0x14bdda
leaq 0xd75bd(%rip), %rcx # 0x14db94
movl $0x42cc, %esi # imm = 0x42CC
xorl %eax, %eax
callq 0x20250
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18compute_boundariesIdEENS2_10boundariesET_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
movq rax, xmm0
mov rcx, rax
btr rcx, 3Fh ; '?'
mov rdx, 7FF0000000000000h
cmp rcx, rdx
jge loc_765A6
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jbe loc_765C2
mov rbx, rdi
mov rcx, 10000000000000h
dec rcx
and rcx, rax
mov rdx, rax
shr rdx, 34h
mov r14, rcx
bts r14, 34h ; '4'
lea esi, [rdx-433h]
test rdx, rdx
cmovz r14, rcx
mov r15d, 0FFFFFBCEh
cmovnz r15d, esi
test rcx, rcx
setz cl
shr rax, 35h
setnz al
lea rdx, [r14+r14]
lea esi, [r15-1]
lea rdi, ds:0[r14*4]
test al, cl
cmovz rdi, rdx
lea eax, [r15-2]
cmovz eax, esi
dec rdi
lea r12, [rsp+48h+var_40]
mov [r12], rdi
mov [r12+8], eax
lea rdi, ds:1[r14*2]
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp9normalizeES3_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
mov [rsp+48h+var_48], rax
mov ebp, edx
mov rdi, r12
mov esi, edx
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp12normalize_toERKS3_i; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize_to(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,int)
mov r12, rax
mov r13d, edx
mov rdi, r14
mov esi, r15d
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp9normalizeES3_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
mov [rbx], rax
mov [rbx+8], edx
mov [rbx+10h], r12
mov [rbx+18h], r13d
mov rax, [rsp+48h+var_48]
mov [rbx+20h], rax
mov [rbx+28h], ebp
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_765A6:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aStdIsfiniteVal; "std::isfinite(value)"
mov esi, 42CBh
jmp short loc_765DC
loc_765C2:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aValue0; "value > 0"
mov esi, 42CCh
loc_765DC:
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(
long long a1,
double a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
char a8,
int a9,
char a10,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *a11)
{
long long v12; // r14
unsigned int v13; // r15d
bool v14; // cl
bool v15; // al
long long v16; // rdi
bool v17; // zf
unsigned int v18; // eax
unsigned int v19; // edx
unsigned int v20; // ebp
long long v21; // r12
int v22; // edx
int v23; // r13d
int v24; // edx
int v26; // esi
int v27; // edx
int v28; // ecx
int v29; // r8d
int v30; // r9d
long long v31; // [rsp+0h] [rbp-48h]
long long v32; // [rsp+8h] [rbp-40h] BYREF
unsigned int v33; // [rsp+10h] [rbp-38h]
if ( (*(_QWORD *)&a2 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
{
v26 = 17099;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
17099LL,
"GGML_ASSERT(%s) failed",
"std::isfinite(value)");
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
(int)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
v26,
v27,
v28,
v29,
v30,
a8,
a9,
a10,
a11);
}
if ( a2 <= 0.0 )
{
v26 = 17100;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
17100LL,
"GGML_ASSERT(%s) failed",
"value > 0");
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
(int)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
v26,
v27,
v28,
v29,
v30,
a8,
a9,
a10,
a11);
}
v12 = *(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL | 0x10000000000000LL;
if ( !(*(_QWORD *)&a2 >> 52) )
v12 = *(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL;
v13 = -1074;
if ( *(_QWORD *)&a2 >> 52 )
v13 = (*(_QWORD *)&a2 >> 52) - 1075;
v14 = (*(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL) == 0;
v15 = *(_QWORD *)&a2 >> 53 != 0LL;
v16 = 4 * v12;
v17 = !v14 || !v15;
if ( !v14 || !v15 )
v16 = 2 * v12;
v18 = v13 - 2;
if ( v17 )
v18 = v13 - 1;
v32 = v16 - 1;
v33 = v18;
v31 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(2 * v12 + 1, v13 - 1);
v20 = v19;
v21 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize_to(&v32, v19);
v23 = v22;
*(_QWORD *)a1 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(v12, v13);
*(_DWORD *)(a1 + 8) = v24;
*(_QWORD *)(a1 + 16) = v21;
*(_DWORD *)(a1 + 24) = v23;
*(_QWORD *)(a1 + 32) = v31;
*(_DWORD *)(a1 + 40) = v20;
return a1;
}
| compute_boundaries<double>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOVQ RAX,XMM0
MOV RCX,RAX
BTR RCX,0x3f
MOV RDX,0x7ff0000000000000
CMP RCX,RDX
JGE 0x001765a6
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JBE 0x001765c2
MOV RBX,RDI
MOV RCX,0x10000000000000
DEC RCX
AND RCX,RAX
MOV RDX,RAX
SHR RDX,0x34
MOV R14,RCX
BTS R14,0x34
LEA ESI,[RDX + -0x433]
TEST RDX,RDX
CMOVZ R14,RCX
MOV R15D,0xfffffbce
CMOVNZ R15D,ESI
TEST RCX,RCX
SETZ CL
SHR RAX,0x35
SETNZ AL
LEA RDX,[R14 + R14*0x1]
LEA ESI,[R15 + -0x1]
LEA RDI,[R14*0x4]
TEST AL,CL
CMOVZ RDI,RDX
LEA EAX,[R15 + -0x2]
CMOVZ EAX,ESI
DEC RDI
LEA R12,[RSP + 0x8]
MOV qword ptr [R12],RDI
MOV dword ptr [R12 + 0x8],EAX
LEA RDI,[0x1 + R14*0x2]
CALL 0x00176714
MOV qword ptr [RSP],RAX
MOV EBP,EDX
MOV RDI,R12
MOV ESI,EDX
CALL 0x00176756
MOV R12,RAX
MOV R13D,EDX
MOV RDI,R14
MOV ESI,R15D
CALL 0x00176714
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x8],EDX
MOV qword ptr [RBX + 0x10],R12
MOV dword ptr [RBX + 0x18],R13D
MOV RAX,qword ptr [RSP]
MOV qword ptr [RBX + 0x20],RAX
MOV dword ptr [RBX + 0x28],EBP
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001765a6:
LEA RDI,[0x24bd8e]
LEA RDX,[0x24bdda]
LEA RCX,[0x24da7b]
MOV ESI,0x42cb
JMP 0x001765dc
LAB_001765c2:
LEA RDI,[0x24bd8e]
LEA RDX,[0x24bdda]
LEA RCX,[0x24db94]
MOV ESI,0x42cc
LAB_001765dc:
XOR EAX,EAX
CALL 0x00120250
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double) */
dtoa_impl * __thiscall
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>
(dtoa_impl *this,double param_1)
{
diyfp *pdVar1;
char *pcVar2;
int8 uVar3;
diyfp *pdVar4;
int iVar5;
bool bVar6;
int1 auVar7 [12];
int1 auVar8 [12];
int1 auVar9 [12];
long local_40;
int local_38;
if ((ulong)ABS(param_1) < 0x7ff0000000000000) {
if (0.0 < param_1) {
pdVar1 = (diyfp *)((ulong)param_1 & 0xfffffffffffff);
bVar6 = (ulong)param_1 >> 0x34 == 0;
pdVar4 = (diyfp *)((ulong)pdVar1 | 0x10000000000000);
if (bVar6) {
pdVar4 = pdVar1;
}
iVar5 = -0x432;
if (!bVar6) {
iVar5 = (uint)((ulong)param_1 >> 0x34) - 0x433;
}
bVar6 = (ulong)param_1 >> 0x35 == 0;
local_40 = (long)pdVar4 * 4;
if (bVar6 || pdVar1 != (diyfp *)0x0) {
local_40 = (long)pdVar4 * 2;
}
local_38 = iVar5 + -2;
if (bVar6 || pdVar1 != (diyfp *)0x0) {
local_38 = iVar5 + -1;
}
local_40 = local_40 + -1;
auVar7 = diyfp::normalize((diyfp *)((long)pdVar4 * 2 + 1));
auVar8 = diyfp::normalize_to((diyfp *)&local_40,auVar7._8_4_);
auVar9 = diyfp::normalize(pdVar4,iVar5);
*(int1 (*) [12])this = auVar9;
*(int1 (*) [12])(this + 0x10) = auVar8;
*(int1 (*) [12])(this + 0x20) = auVar7;
return this;
}
pcVar2 = "value > 0";
uVar3 = 0x42cc;
}
else {
pcVar2 = "std::isfinite(value)";
uVar3 = 0x42cb;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
51,247 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double) | monkey531[P]llama/common/./json.hpp | boundaries compute_boundaries(FloatType value)
{
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// Convert the IEEE representation into a diyfp.
//
// If v is denormal:
// value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1))
// If v is normalized:
// value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
static_assert(std::numeric_limits<FloatType>::is_iec559,
"internal error: dtoa_short requires an IEEE-754 floating-point implementation");
constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
constexpr int kMinExp = 1 - kBias;
constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
const std::uint64_t E = bits >> (kPrecision - 1);
const std::uint64_t F = bits & (kHiddenBit - 1);
const bool is_denormal = E == 0;
const diyfp v = is_denormal
? diyfp(F, kMinExp)
: diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
// Compute the boundaries m- and m+ of the floating-point value
// v = f * 2^e.
//
// Determine v- and v+, the floating-point predecessor and successor if v,
// respectively.
//
// v- = v - 2^e if f != 2^(p-1) or e == e_min (A)
// = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B)
//
// v+ = v + 2^e
//
// Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
// between m- and m+ round to v, regardless of how the input rounding
// algorithm breaks ties.
//
// ---+-------------+-------------+-------------+-------------+--- (A)
// v- m- v m+ v+
//
// -----------------+------+------+-------------+-------------+--- (B)
// v- m- v m+ v+
const bool lower_boundary_is_closer = F == 0 && E > 1;
const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
const diyfp m_minus = lower_boundary_is_closer
? diyfp(4 * v.f - 1, v.e - 2) // (B)
: diyfp(2 * v.f - 1, v.e - 1); // (A)
// Determine the normalized w+ = m+.
const diyfp w_plus = diyfp::normalize(m_plus);
// Determine w- = m- such that e_(w-) = e_(w+).
const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
return {diyfp::normalize(v), w_minus, w_plus};
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %xmm0, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
jge 0x681b6
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x681d2
movq %rdi, %rbx
movabsq $0x10000000000000, %rcx # imm = 0x10000000000000
decq %rcx
andq %rax, %rcx
movq %rax, %rdx
shrq $0x34, %rdx
movq %rcx, %r14
btsq $0x34, %r14
leal -0x433(%rdx), %esi
testq %rdx, %rdx
cmoveq %rcx, %r14
movl $0xfffffbce, %r15d # imm = 0xFFFFFBCE
cmovnel %esi, %r15d
testq %rcx, %rcx
sete %cl
shrq $0x35, %rax
setne %al
leal -0x1(%r15), %esi
addl $0xfffffbcb, %edx # imm = 0xFFFFFBCB
testb %cl, %al
cmovel %esi, %edx
leaq -0x1(%r14,%r14), %rax
movabsq $0x3fffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFF
cmoveq %rax, %rcx
leaq 0x8(%rsp), %r12
movq %rcx, (%r12)
movl %edx, 0x8(%r12)
leaq 0x1(,%r14,2), %rdi
callq 0x68322
movq %rax, (%rsp)
movl %edx, %ebp
movq %r12, %rdi
movl %edx, %esi
callq 0x68362
movq %rax, %r12
movl %edx, %r13d
movq %r14, %rdi
movl %r15d, %esi
callq 0x68322
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movl %r13d, 0x18(%rbx)
movq (%rsp), %rax
movq %rax, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x89b59(%rip), %rdi # 0xf1d16
leaq 0x89b9e(%rip), %rdx # 0xf1d62
leaq 0x8b838(%rip), %rcx # 0xf3a03
movl $0x42cb, %esi # imm = 0x42CB
jmp 0x681ec
leaq 0x89b3d(%rip), %rdi # 0xf1d16
leaq 0x89b82(%rip), %rdx # 0xf1d62
leaq 0x8b935(%rip), %rcx # 0xf3b1c
movl $0x42cc, %esi # imm = 0x42CC
xorl %eax, %eax
callq 0x292a0
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18compute_boundariesIdEENS2_10boundariesET_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
movq rax, xmm0
mov rcx, rax
btr rcx, 3Fh ; '?'
mov rdx, 7FF0000000000000h
cmp rcx, rdx
jge loc_681B6
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jbe loc_681D2
mov rbx, rdi
mov rcx, 10000000000000h
dec rcx
and rcx, rax
mov rdx, rax
shr rdx, 34h
mov r14, rcx
bts r14, 34h ; '4'
lea esi, [rdx-433h]
test rdx, rdx
cmovz r14, rcx
mov r15d, 0FFFFFBCEh
cmovnz r15d, esi
test rcx, rcx
setz cl
shr rax, 35h
setnz al
lea esi, [r15-1]
add edx, 0FFFFFBCBh
test al, cl
cmovz edx, esi
lea rax, [r14+r14-1]
mov rcx, 3FFFFFFFFFFFFFh
cmovz rcx, rax
lea r12, [rsp+48h+var_40]
mov [r12], rcx
mov [r12+8], edx
lea rdi, ds:1[r14*2]
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp9normalizeES3_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
mov [rsp+48h+var_48], rax
mov ebp, edx
mov rdi, r12
mov esi, edx
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp12normalize_toERKS3_i; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize_to(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,int)
mov r12, rax
mov r13d, edx
mov rdi, r14
mov esi, r15d
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp9normalizeES3_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
mov [rbx], rax
mov [rbx+8], edx
mov [rbx+10h], r12
mov [rbx+18h], r13d
mov rax, [rsp+48h+var_48]
mov [rbx+20h], rax
mov [rbx+28h], ebp
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_681B6:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aStdIsfiniteVal; "std::isfinite(value)"
mov esi, 42CBh
jmp short loc_681EC
loc_681D2:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aValue0; "value > 0"
mov esi, 42CCh
loc_681EC:
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(
long long a1,
double a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9,
long long a10,
long long a11)
{
long long v11; // r14
int v12; // r15d
bool v13; // cl
bool v14; // al
int v15; // edx
bool v16; // zf
long long v17; // rcx
unsigned int v18; // edx
unsigned int v19; // ebp
long long v20; // r12
int v21; // edx
int v22; // r13d
int v23; // edx
long long v25; // rsi
long long v26; // rdx
long long v27; // rcx
long long v28; // r8
long long v29; // r9
long long v30; // [rsp+0h] [rbp-48h]
long long v31; // [rsp+8h] [rbp-40h] BYREF
int v32; // [rsp+10h] [rbp-38h]
if ( (*(_QWORD *)&a2 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
{
v25 = 17099LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
17099LL,
"GGML_ASSERT(%s) failed",
"std::isfinite(value)");
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
v25,
v26,
v27,
v28,
v29,
a8,
a9,
a10,
a11);
}
if ( a2 <= 0.0 )
{
v25 = 17100LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
17100LL,
"GGML_ASSERT(%s) failed",
"value > 0");
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
v25,
v26,
v27,
v28,
v29,
a8,
a9,
a10,
a11);
}
v11 = *(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL | 0x10000000000000LL;
if ( !(*(_QWORD *)&a2 >> 52) )
v11 = *(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL;
v12 = -1074;
if ( *(_QWORD *)&a2 >> 52 )
v12 = (*(_QWORD *)&a2 >> 52) - 1075;
v13 = (*(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL) == 0;
v14 = *(_QWORD *)&a2 >> 53 != 0LL;
v15 = (*(_QWORD *)&a2 >> 52) - 1077;
v16 = !v13 || !v14;
if ( !v13 || !v14 )
v15 = v12 - 1;
v17 = 0x3FFFFFFFFFFFFFLL;
if ( v16 )
v17 = 2 * v11 - 1;
v31 = v17;
v32 = v15;
v30 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(2 * v11 + 1);
v19 = v18;
v20 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize_to(&v31, v18);
v22 = v21;
*(_QWORD *)a1 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(v11);
*(_DWORD *)(a1 + 8) = v23;
*(_QWORD *)(a1 + 16) = v20;
*(_DWORD *)(a1 + 24) = v22;
*(_QWORD *)(a1 + 32) = v30;
*(_DWORD *)(a1 + 40) = v19;
return a1;
}
| compute_boundaries<double>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOVQ RAX,XMM0
MOV RCX,RAX
BTR RCX,0x3f
MOV RDX,0x7ff0000000000000
CMP RCX,RDX
JGE 0x001681b6
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JBE 0x001681d2
MOV RBX,RDI
MOV RCX,0x10000000000000
DEC RCX
AND RCX,RAX
MOV RDX,RAX
SHR RDX,0x34
MOV R14,RCX
BTS R14,0x34
LEA ESI,[RDX + -0x433]
TEST RDX,RDX
CMOVZ R14,RCX
MOV R15D,0xfffffbce
CMOVNZ R15D,ESI
TEST RCX,RCX
SETZ CL
SHR RAX,0x35
SETNZ AL
LEA ESI,[R15 + -0x1]
ADD EDX,0xfffffbcb
TEST AL,CL
CMOVZ EDX,ESI
LEA RAX,[R14 + R14*0x1 + -0x1]
MOV RCX,0x3fffffffffffff
CMOVZ RCX,RAX
LEA R12,[RSP + 0x8]
MOV qword ptr [R12],RCX
MOV dword ptr [R12 + 0x8],EDX
LEA RDI,[0x1 + R14*0x2]
CALL 0x00168322
MOV qword ptr [RSP],RAX
MOV EBP,EDX
MOV RDI,R12
MOV ESI,EDX
CALL 0x00168362
MOV R12,RAX
MOV R13D,EDX
MOV RDI,R14
MOV ESI,R15D
CALL 0x00168322
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x8],EDX
MOV qword ptr [RBX + 0x10],R12
MOV dword ptr [RBX + 0x18],R13D
MOV RAX,qword ptr [RSP]
MOV qword ptr [RBX + 0x20],RAX
MOV dword ptr [RBX + 0x28],EBP
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001681b6:
LEA RDI,[0x1f1d16]
LEA RDX,[0x1f1d62]
LEA RCX,[0x1f3a03]
MOV ESI,0x42cb
JMP 0x001681ec
LAB_001681d2:
LEA RDI,[0x1f1d16]
LEA RDX,[0x1f1d62]
LEA RCX,[0x1f3b1c]
MOV ESI,0x42cc
LAB_001681ec:
XOR EAX,EAX
CALL 0x001292a0
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double) */
dtoa_impl * __thiscall
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>
(dtoa_impl *this,double param_1)
{
uint uVar1;
diyfp *pdVar2;
char *pcVar3;
int8 uVar4;
diyfp *pdVar5;
int iVar6;
bool bVar7;
int1 auVar8 [12];
int1 auVar9 [12];
int1 auVar10 [12];
long local_40;
int local_38;
if ((ulong)ABS(param_1) < 0x7ff0000000000000) {
if (0.0 < param_1) {
pdVar2 = (diyfp *)((ulong)param_1 & 0xfffffffffffff);
uVar1 = (uint)((ulong)param_1 >> 0x20);
bVar7 = (ulong)param_1 >> 0x34 == 0;
pdVar5 = (diyfp *)((ulong)pdVar2 | 0x10000000000000);
if (bVar7) {
pdVar5 = pdVar2;
}
iVar6 = -0x432;
if (!bVar7) {
iVar6 = (uVar1 >> 0x14) - 0x433;
}
bVar7 = (ulong)param_1 >> 0x35 == 0;
local_38 = (uVar1 >> 0x14) - 0x435;
if (bVar7 || pdVar2 != (diyfp *)0x0) {
local_38 = iVar6 + -1;
}
local_40 = 0x3fffffffffffff;
if (bVar7 || pdVar2 != (diyfp *)0x0) {
local_40 = (long)pdVar5 * 2 + -1;
}
auVar8 = diyfp::normalize((diyfp *)((long)pdVar5 * 2 + 1));
auVar9 = diyfp::normalize_to((diyfp *)&local_40,auVar8._8_4_);
auVar10 = diyfp::normalize(pdVar5,iVar6);
*(int1 (*) [12])this = auVar10;
*(int1 (*) [12])(this + 0x10) = auVar9;
*(int1 (*) [12])(this + 0x20) = auVar8;
return this;
}
pcVar3 = "value > 0";
uVar4 = 0x42cc;
}
else {
pcVar3 = "std::isfinite(value)";
uVar4 = 0x42cb;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",uVar4,
"GGML_ASSERT(%s) failed",pcVar3);
}
| |
51,248 | start_of_next_entry | eloqsql/storage/maria/ma_blockrec.c | static inline uint start_of_next_entry(uchar *dir)
{
uchar *prev;
/*
Find previous used entry. (There is always a previous entry as
the directory never starts with a deleted entry)
*/
for (prev= dir - DIR_ENTRY_SIZE ;
prev[0] == 0 && prev[1] == 0 ;
prev-= DIR_ENTRY_SIZE)
{}
return (uint) uint2korr(prev);
} | O0 | c | start_of_next_entry:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x7f846
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x7f84f
jmp 0x7f85f
jmp 0x7f851
movq -0x10(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x7f824
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
popq %rbp
retq
nopl (%rax,%rax)
| start_of_next_entry:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
add rax, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_10], rax
loc_7F824:
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_11], al
jnz short loc_7F846
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 0
setz al
mov [rbp+var_11], al
loc_7F846:
mov al, [rbp+var_11]
test al, 1
jnz short loc_7F84F
jmp short loc_7F85F
loc_7F84F:
jmp short $+2
loc_7F851:
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_10], rax
jmp short loc_7F824
loc_7F85F:
mov rax, [rbp+var_10]
movzx eax, word ptr [rax]
pop rbp
retn
| long long start_of_next_entry(long long a1)
{
bool v2; // [rsp+1h] [rbp-11h]
_BYTE *i; // [rsp+2h] [rbp-10h]
for ( i = (_BYTE *)(a1 - 4); ; i -= 4 )
{
v2 = 0;
if ( !*i )
v2 = i[1] == 0;
if ( !v2 )
break;
}
return *(unsigned __int16 *)i;
}
| start_of_next_entry:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,-0x4
MOV qword ptr [RBP + -0x10],RAX
LAB_0017f824:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x11],AL
JNZ 0x0017f846
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x0
SETZ AL
MOV byte ptr [RBP + -0x11],AL
LAB_0017f846:
MOV AL,byte ptr [RBP + -0x11]
TEST AL,0x1
JNZ 0x0017f84f
JMP 0x0017f85f
LAB_0017f84f:
JMP 0x0017f851
LAB_0017f851:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x4
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0017f824
LAB_0017f85f:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX]
POP RBP
RET
|
int2 start_of_next_entry(long param_1)
{
bool bVar1;
char *local_18;
local_18 = (char *)(param_1 + -4);
while( true ) {
bVar1 = false;
if (*local_18 == '\0') {
bVar1 = local_18[1] == '\0';
}
if (!bVar1) break;
local_18 = local_18 + -4;
}
return *(int2 *)local_18;
}
| |
51,249 | ggml_is_contiguous | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | bool ggml_is_contiguous(const struct ggml_tensor * tensor) {
static_assert(GGML_MAX_DIMS == 4, "GGML_MAX_DIMS is not 4 - update this function");
return
tensor->nb[0] == ggml_type_size(tensor->type) &&
tensor->nb[1] == (tensor->nb[0]*tensor->ne[0])/ggml_blck_size(tensor->type) &&
tensor->nb[2] == tensor->nb[1]*tensor->ne[1] &&
tensor->nb[3] == tensor->nb[2]*tensor->ne[2];
} | O2 | c | ggml_is_contiguous:
movq 0x30(%rdi), %rax
movl (%rdi), %ecx
imulq $0x48, %rcx, %rcx
leaq 0x6d4d6(%rip), %rdx # 0xd52a0
cmpq 0x10(%rcx,%rdx), %rax
jne 0x67e07
imulq 0x10(%rdi), %rax
movq 0x38(%rdi), %rsi
movslq 0x8(%rcx,%rdx), %r8
xorl %ecx, %ecx
xorl %edx, %edx
divq %r8
cmpq %rax, %rsi
jne 0x67e09
movq 0x40(%rdi), %rax
imulq 0x18(%rdi), %rsi
cmpq %rsi, %rax
jne 0x67e07
imulq 0x20(%rdi), %rax
cmpq %rax, 0x48(%rdi)
sete %cl
jmp 0x67e09
xorl %ecx, %ecx
movl %ecx, %eax
retq
| ggml_is_contiguous:
mov rax, [rdi+30h]
mov ecx, [rdi]
imul rcx, 48h ; 'H'
lea rdx, type_traits
cmp rax, [rcx+rdx+10h]
jnz short loc_67E07
imul rax, [rdi+10h]
mov rsi, [rdi+38h]
movsxd r8, dword ptr [rcx+rdx+8]
xor ecx, ecx
xor edx, edx
div r8
cmp rsi, rax
jnz short loc_67E09
mov rax, [rdi+40h]
imul rsi, [rdi+18h]
cmp rax, rsi
jnz short loc_67E07
imul rax, [rdi+20h]
cmp [rdi+48h], rax
setz cl
jmp short loc_67E09
loc_67E07:
xor ecx, ecx
loc_67E09:
mov eax, ecx
retn
| long long ggml_is_contiguous(_QWORD *a1)
{
char *v1; // rax
long long v2; // rcx
long long v3; // rsi
unsigned long long v4; // r8
unsigned int v5; // ecx
long long v6; // rax
v1 = (char *)a1[6];
v2 = 9LL * *(unsigned int *)a1;
if ( v1 != (&type_traits)[v2 + 2] )
return 0;
v3 = a1[7];
v4 = SLODWORD((&type_traits)[v2 + 1]);
v5 = 0;
if ( v3 == a1[2] * (_QWORD)v1 / v4 )
{
v6 = a1[8];
if ( v6 == a1[3] * v3 )
{
LOBYTE(v5) = a1[9] == a1[4] * v6;
return v5;
}
return 0;
}
return v5;
}
| ggml_is_contiguous:
MOV RAX,qword ptr [RDI + 0x30]
MOV ECX,dword ptr [RDI]
IMUL RCX,RCX,0x48
LEA RDX,[0x1d52a0]
CMP RAX,qword ptr [RCX + RDX*0x1 + 0x10]
JNZ 0x00167e07
IMUL RAX,qword ptr [RDI + 0x10]
MOV RSI,qword ptr [RDI + 0x38]
MOVSXD R8,dword ptr [RCX + RDX*0x1 + 0x8]
XOR ECX,ECX
XOR EDX,EDX
DIV R8
CMP RSI,RAX
JNZ 0x00167e09
MOV RAX,qword ptr [RDI + 0x40]
IMUL RSI,qword ptr [RDI + 0x18]
CMP RAX,RSI
JNZ 0x00167e07
IMUL RAX,qword ptr [RDI + 0x20]
CMP qword ptr [RDI + 0x48],RAX
SETZ CL
JMP 0x00167e09
LAB_00167e07:
XOR ECX,ECX
LAB_00167e09:
MOV EAX,ECX
RET
|
bool ggml_is_contiguous(uint *param_1)
{
if (*(long *)(param_1 + 0xc) == *(long *)(type_traits + (ulong)*param_1 * 0x48 + 0x10)) {
if (*(ulong *)(param_1 + 0xe) !=
(ulong)(*(long *)(param_1 + 0xc) * *(long *)(param_1 + 4)) /
(ulong)(long)*(int *)(type_traits + (ulong)*param_1 * 0x48 + 8)) {
return false;
}
if (*(long *)(param_1 + 0x10) == *(ulong *)(param_1 + 0xe) * *(long *)(param_1 + 6)) {
return *(long *)(param_1 + 0x12) == *(long *)(param_1 + 0x10) * *(long *)(param_1 + 8);
}
}
return false;
}
| |
51,250 | ggml_is_contiguous | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | bool ggml_is_contiguous(const struct ggml_tensor * tensor) {
static_assert(GGML_MAX_DIMS == 4, "GGML_MAX_DIMS is not 4 - update this function");
return
tensor->nb[0] == ggml_type_size(tensor->type) &&
tensor->nb[1] == (tensor->nb[0]*tensor->ne[0])/ggml_blck_size(tensor->type) &&
tensor->nb[2] == tensor->nb[1]*tensor->ne[1] &&
tensor->nb[3] == tensor->nb[2]*tensor->ne[2];
} | O3 | c | ggml_is_contiguous:
movq 0x30(%rdi), %rax
movl (%rdi), %ecx
leaq (%rcx,%rcx,8), %rcx
leaq 0x671fc(%rip), %rdx # 0xf42b0
cmpq 0x10(%rdx,%rcx,8), %rax
jne 0x8d0f1
imulq 0x10(%rdi), %rax
movq 0x38(%rdi), %rsi
movslq 0x8(%rdx,%rcx,8), %r8
xorl %ecx, %ecx
xorl %edx, %edx
divq %r8
cmpq %rax, %rsi
jne 0x8d0f3
movq 0x40(%rdi), %rax
imulq 0x18(%rdi), %rsi
cmpq %rsi, %rax
jne 0x8d0f1
imulq 0x20(%rdi), %rax
cmpq %rax, 0x48(%rdi)
sete %cl
jmp 0x8d0f3
xorl %ecx, %ecx
movl %ecx, %eax
retq
| ggml_is_contiguous:
mov rax, [rdi+30h]
mov ecx, [rdi]
lea rcx, [rcx+rcx*8]
lea rdx, type_traits
cmp rax, [rdx+rcx*8+10h]
jnz short loc_8D0F1
imul rax, [rdi+10h]
mov rsi, [rdi+38h]
movsxd r8, dword ptr [rdx+rcx*8+8]
xor ecx, ecx
xor edx, edx
div r8
cmp rsi, rax
jnz short loc_8D0F3
mov rax, [rdi+40h]
imul rsi, [rdi+18h]
cmp rax, rsi
jnz short loc_8D0F1
imul rax, [rdi+20h]
cmp [rdi+48h], rax
setz cl
jmp short loc_8D0F3
loc_8D0F1:
xor ecx, ecx
loc_8D0F3:
mov eax, ecx
retn
| long long ggml_is_contiguous(_QWORD *a1)
{
char *v1; // rax
long long v2; // rsi
unsigned int v3; // ecx
long long v4; // rax
v1 = (char *)a1[6];
if ( v1 != (&type_traits)[9 * *(unsigned int *)a1 + 2] )
return 0;
v2 = a1[7];
v3 = 0;
if ( v2 == a1[2] * (_QWORD)v1 / (unsigned long long)SLODWORD((&type_traits)[9 * *(unsigned int *)a1 + 1]) )
{
v4 = a1[8];
if ( v4 == a1[3] * v2 )
{
LOBYTE(v3) = a1[9] == a1[4] * v4;
return v3;
}
return 0;
}
return v3;
}
| |||
51,251 | lunasvg::SVGLengthList::parse(std::basic_string_view<char, std::char_traits<char>>) | dmazzella[P]pylunasvg/lunasvg/source/svgproperty.cpp | bool SVGLengthList::parse(std::string_view input)
{
m_values.clear();
while(!input.empty()) {
size_t count = 0;
while(count < input.length() && input[count] != ',' && !IS_WS(input[count]))
++count;
if(count == 0)
break;
Length value(0, LengthUnits::None);
if(!value.parse(input.substr(0, count), m_negativeMode))
return false;
input.remove_prefix(count);
skipOptionalSpacesOrComma(input);
m_values.push_back(value);
}
return true;
} | O1 | cpp | lunasvg::SVGLengthList::parse(std::basic_string_view<char, std::char_traits<char>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x1f927
movq %rax, 0x18(%rbx)
leaq 0x10(%rbx), %r14
movq %rsp, %r15
movabsq $0x100100002600, %r13 # imm = 0x100100002600
movq 0x8(%rsp), %rsi
movb $0x1, %bpl
testq %rsi, %rsi
je 0x1f9f3
movq 0x10(%rsp), %rax
xorl %r12d, %r12d
movzbl (%rax,%r12), %ecx
cmpq $0x2c, %rcx
ja 0x1f962
btq %rcx, %r13
jb 0x1f96d
incq %r12
cmpq %r12, %rsi
jne 0x1f951
movq %rsi, %r12
testq %r12, %r12
je 0x1f9d0
movl $0x0, (%rsp)
movb $0x0, 0x4(%rsp)
cmpq %r12, %rsi
cmovaeq %r12, %rsi
movq 0x10(%rsp), %rdx
movzbl 0xa(%rbx), %ecx
movq %r15, %rdi
callq 0x1f5d2
movl $0x1, %ecx
testb %al, %al
je 0x1f9e4
addq %r12, 0x10(%rsp)
subq %r12, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
movl $0x2c, %esi
callq 0x176d5
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0x1f9d7
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x1f9e2
movl $0x3, %ecx
jmp 0x1f9e4
movq %r14, %rdi
movq %r15, %rdx
callq 0x20a0c
xorl %ecx, %ecx
testl %ecx, %ecx
je 0x1f938
cmpl $0x3, %ecx
je 0x1f9f3
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN7lunasvg13SVGLengthList5parseESt17basic_string_viewIcSt11char_traitsIcEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov [rsp+48h+var_40], rsi
mov [rsp+48h+var_38], rdx
mov rax, [rdi+10h]
cmp [rdi+18h], rax
jz short loc_1F927
mov [rbx+18h], rax
loc_1F927:
lea r14, [rbx+10h]
mov r15, rsp
mov r13, 100100002600h
loc_1F938:
mov rsi, [rsp+48h+var_40]
mov bpl, 1
test rsi, rsi
jz loc_1F9F3
mov rax, [rsp+48h+var_38]
xor r12d, r12d
loc_1F951:
movzx ecx, byte ptr [rax+r12]
cmp rcx, 2Ch ; ','
ja short loc_1F962
bt r13, rcx
jb short loc_1F96D
loc_1F962:
inc r12
cmp rsi, r12
jnz short loc_1F951
mov r12, rsi
loc_1F96D:
test r12, r12
jz short loc_1F9D0
mov dword ptr [rsp+48h+var_48], 0
mov byte ptr [rsp+48h+var_48+4], 0
cmp rsi, r12
cmovnb rsi, r12
mov rdx, [rsp+48h+var_38]
movzx ecx, byte ptr [rbx+0Ah]
mov rdi, r15
call _ZN7lunasvg6Length5parseESt17basic_string_viewIcSt11char_traitsIcEENS_18LengthNegativeModeE; lunasvg::Length::parse(std::string_view,lunasvg::LengthNegativeMode)
mov ecx, 1
test al, al
jz short loc_1F9E4
add [rsp+48h+var_38], r12
sub [rsp+48h+var_40], r12
lea rdi, [rsp+48h+var_40]
mov esi, 2Ch ; ','
call _ZN7lunasvg29skipOptionalSpacesOrDelimiterERSt17basic_string_viewIcSt11char_traitsIcEEc; lunasvg::skipOptionalSpacesOrDelimiter(std::string_view &,char)
mov rsi, [rbx+18h]
cmp rsi, [rbx+20h]
jz short loc_1F9D7
mov rax, [rsp+48h+var_48]
mov [rsi], rax
add qword ptr [rbx+18h], 8
jmp short loc_1F9E2
loc_1F9D0:
mov ecx, 3
jmp short loc_1F9E4
loc_1F9D7:
mov rdi, r14
mov rdx, r15
call _ZNSt6vectorIN7lunasvg6LengthESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<lunasvg::Length>::_M_realloc_insert<lunasvg::Length const&>(__gnu_cxx::__normal_iterator<lunasvg::Length*,std::vector<lunasvg::Length>>,lunasvg::Length const&)
loc_1F9E2:
xor ecx, ecx
loc_1F9E4:
test ecx, ecx
jz loc_1F938
cmp ecx, 3
jz short loc_1F9F3
xor ebp, ebp
loc_1F9F3:
mov eax, ebp
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long lunasvg::SVGLengthList::parse(long long a1, unsigned long long a2, unsigned __int8 *a3)
{
unsigned int v3; // ebp
long long v4; // rax
long long v5; // r13
long long v6; // rsi
unsigned long long v7; // r12
unsigned long long v8; // rcx
char v9; // al
int v10; // ecx
_QWORD *v11; // rsi
long long v13; // [rsp+0h] [rbp-48h] BYREF
unsigned long long v14; // [rsp+8h] [rbp-40h] BYREF
unsigned __int8 *v15; // [rsp+10h] [rbp-38h]
v14 = a2;
v15 = a3;
v4 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 24) != v4 )
*(_QWORD *)(a1 + 24) = v4;
v5 = 0x100100002600LL;
while ( 1 )
{
v6 = v14;
LOBYTE(v3) = 1;
if ( !v14 )
return v3;
v7 = 0LL;
while ( 1 )
{
v8 = v15[v7];
if ( v8 <= 0x2C )
{
if ( _bittest64(&v5, v8) )
break;
}
if ( v14 == ++v7 )
{
v7 = v14;
break;
}
}
if ( v7 )
{
LODWORD(v13) = 0;
BYTE4(v13) = 0;
if ( v14 >= v7 )
v6 = v7;
v9 = lunasvg::Length::parse((long long)&v13, v6, v15, *(_BYTE *)(a1 + 10));
v10 = 1;
if ( v9 )
{
v15 += v7;
v14 -= v7;
lunasvg::skipOptionalSpacesOrDelimiter((long long *)&v14, 44);
v11 = *(_QWORD **)(a1 + 24);
if ( v11 == *(_QWORD **)(a1 + 32) )
{
std::vector<lunasvg::Length>::_M_realloc_insert<lunasvg::Length const&>(a1 + 16, v11, &v13);
}
else
{
*v11 = v13;
*(_QWORD *)(a1 + 24) += 8LL;
}
v10 = 0;
}
}
else
{
v10 = 3;
}
if ( v10 )
{
if ( v10 != 3 )
return 0;
return v3;
}
}
}
| parse:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDI + 0x18],RAX
JZ 0x0011f927
MOV qword ptr [RBX + 0x18],RAX
LAB_0011f927:
LEA R14,[RBX + 0x10]
MOV R15,RSP
MOV R13,0x100100002600
LAB_0011f938:
MOV RSI,qword ptr [RSP + 0x8]
MOV BPL,0x1
TEST RSI,RSI
JZ 0x0011f9f3
MOV RAX,qword ptr [RSP + 0x10]
XOR R12D,R12D
LAB_0011f951:
MOVZX ECX,byte ptr [RAX + R12*0x1]
CMP RCX,0x2c
JA 0x0011f962
BT R13,RCX
JC 0x0011f96d
LAB_0011f962:
INC R12
CMP RSI,R12
JNZ 0x0011f951
MOV R12,RSI
LAB_0011f96d:
TEST R12,R12
JZ 0x0011f9d0
MOV dword ptr [RSP],0x0
MOV byte ptr [RSP + 0x4],0x0
CMP RSI,R12
CMOVNC RSI,R12
MOV RDX,qword ptr [RSP + 0x10]
MOVZX ECX,byte ptr [RBX + 0xa]
MOV RDI,R15
CALL 0x0011f5d2
MOV ECX,0x1
TEST AL,AL
JZ 0x0011f9e4
ADD qword ptr [RSP + 0x10],R12
SUB qword ptr [RSP + 0x8],R12
LEA RDI,[RSP + 0x8]
MOV ESI,0x2c
CALL 0x001176d5
MOV RSI,qword ptr [RBX + 0x18]
CMP RSI,qword ptr [RBX + 0x20]
JZ 0x0011f9d7
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSI],RAX
ADD qword ptr [RBX + 0x18],0x8
JMP 0x0011f9e2
LAB_0011f9d0:
MOV ECX,0x3
JMP 0x0011f9e4
LAB_0011f9d7:
MOV RDI,R14
MOV RDX,R15
CALL 0x00120a0c
LAB_0011f9e2:
XOR ECX,ECX
LAB_0011f9e4:
TEST ECX,ECX
JZ 0x0011f938
CMP ECX,0x3
JZ 0x0011f9f3
XOR EBP,EBP
LAB_0011f9f3:
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* lunasvg::SVGLengthList::parse(std::basic_string_view<char, std::char_traits<char> >) */
ulong lunasvg::SVGLengthList::parse(long param_1,ulong param_2,long param_3)
{
int8 *puVar1;
char cVar2;
int iVar3;
ulong unaff_RBP;
ulong uVar4;
ulong uVar5;
int4 local_48;
uint uStack_44;
ulong local_40;
long local_38;
if (*(long *)(param_1 + 0x18) != *(long *)(param_1 + 0x10)) {
*(long *)(param_1 + 0x18) = *(long *)(param_1 + 0x10);
}
local_40 = param_2;
local_38 = param_3;
do {
unaff_RBP = CONCAT71((int7)(unaff_RBP >> 8),1);
if (local_40 == 0) goto LAB_0011f9f3;
uVar4 = 0;
do {
if (((ulong)*(byte *)(local_38 + uVar4) < 0x2d) &&
(uVar5 = uVar4, (0x100100002600U >> ((ulong)*(byte *)(local_38 + uVar4) & 0x3f) & 1) != 0))
break;
uVar4 = uVar4 + 1;
uVar5 = local_40;
} while (local_40 != uVar4);
if (uVar5 == 0) {
iVar3 = 3;
}
else {
local_48 = 0;
uStack_44 = uStack_44 & 0xffffff00;
uVar4 = local_40;
if (uVar5 <= local_40) {
uVar4 = uVar5;
}
cVar2 = Length::parse(&local_48,uVar4,local_38,*(int1 *)(param_1 + 10));
iVar3 = 1;
if (cVar2 != '\0') {
local_38 = local_38 + uVar5;
local_40 = local_40 - uVar5;
skipOptionalSpacesOrDelimiter((basic_string_view *)&local_40,',');
puVar1 = *(int8 **)(param_1 + 0x18);
if (puVar1 == *(int8 **)(param_1 + 0x20)) {
std::vector<lunasvg::Length,std::allocator<lunasvg::Length>>::
_M_realloc_insert<lunasvg::Length_const&>
((vector<lunasvg::Length,std::allocator<lunasvg::Length>> *)(param_1 + 0x10),
puVar1,&local_48);
}
else {
*puVar1 = CONCAT44(uStack_44,local_48);
*(long *)(param_1 + 0x18) = *(long *)(param_1 + 0x18) + 8;
}
iVar3 = 0;
}
}
} while (iVar3 == 0);
if (iVar3 != 3) {
unaff_RBP = 0;
}
LAB_0011f9f3:
return unaff_RBP & 0xffffffff;
}
| |
51,252 | my_hash_sort_simple | eloqsql/strings/ctype-simple.c | void my_hash_sort_simple(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
register const uchar *sort_order=cs->sort_order;
const uchar *end;
uint16 space_weight= sort_order[' '];
/*
Remove all trailing characters that are equal to space.
We have to do this to be able to compare 'A ' and 'A' as identical.
If the key is long enough, cut the trailing spaces (0x20) using an
optimized function implemented in skip_trailing_spaces().
"len > 16" is just some heuristic here.
Calling skip_triling_space() for short values is not desirable,
because its initialization block may be more expensive than the
performance gained.
*/
end= len > 16 ? skip_trailing_space(key, len) : key + len;
/*
We removed all trailing characters that are binary equal to space 0x20.
Now remove all trailing characters that have weights equal to space.
Some 8bit simple collations may have such characters:
- cp1250_general_ci 0xA0 NO-BREAK SPACE == 0x20 SPACE
- cp1251_ukrainian_ci 0x60 GRAVE ACCENT == 0x20 SPACE
- koi8u_general_ci 0x60 GRAVE ACCENT == 0x20 SPACE
*/
for ( ; key < end ; )
{
if (sort_order[*--end] != space_weight)
{
end++;
break;
}
}
my_hash_sort_simple_nopad(cs, key, end - key, nr1, nr2);
} | O3 | c | my_hash_sort_simple:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x58(%rdi), %rax
leaq (%rsi,%rdx), %rdi
cmpq $0x11, %rdx
jb 0x2d77d
cmpq $0x15, %rdx
jb 0x2d768
movq %rdi, %r10
andq $-0x4, %r10
cmpq %rsi, %r10
jbe 0x2d768
leaq 0x3(%rsi), %r9
andq $-0x4, %r9
movq %rdi, %rdx
movb -0x1(%rdi), %r11b
cmpq %r10, %rdi
jbe 0x2d7e8
leaq -0x1(%rdx), %rdi
cmpb $0x20, %r11b
je 0x2d74c
jmp 0x2d76b
movq %rdi, %rdx
movq %rdx, %rdi
cmpq %rsi, %rdx
jbe 0x2d77d
leaq -0x1(%rdi), %rdx
cmpb $0x20, -0x1(%rdi)
je 0x2d76b
movb 0x20(%rax), %r9b
movq %rdi, %r11
subq %rsi, %r11
movq %rdi, %rdx
movq %r11, %r10
cmpq %rsi, %rdi
jbe 0x2d7a4
leaq -0x1(%rdx), %rdi
movzbl -0x1(%rdx), %ebx
leaq -0x1(%r10), %r11
cmpb %r9b, (%rax,%rbx)
je 0x2d787
movq (%rcx), %rdi
movq (%r8), %r9
testq %r10, %r10
jle 0x2d7df
movl %edi, %r10d
andl $0x3f, %r10d
addq %r9, %r10
movzbl (%rsi), %r11d
movzbl (%rax,%r11), %r11d
imulq %r10, %r11
movq %rdi, %r10
shlq $0x8, %r10
addq %r11, %r10
xorq %r10, %rdi
addq $0x3, %r9
incq %rsi
cmpq %rdx, %rsi
jb 0x2d7af
movq %rdi, (%rcx)
movq %r9, (%r8)
popq %rbx
popq %rbp
retq
cmpb $0x20, %r11b
setne %dil
cmpq %r10, %r9
setae %r10b
orb %dil, %r10b
jne 0x2d76b
movq %rdx, %rdi
movq %rdi, %rdx
cmpq %r9, %rdi
jbe 0x2d76b
leaq -0x4(%rdx), %rdi
cmpl $0x20202020, -0x4(%rdx) # imm = 0x20202020
je 0x2d803
jmp 0x2d76b
| my_hash_sort_simple:
push rbp
mov rbp, rsp
push rbx
mov rax, [rdi+58h]
lea rdi, [rsi+rdx]
cmp rdx, 11h
jb short loc_2D77D
cmp rdx, 15h
jb short loc_2D768
mov r10, rdi
and r10, 0FFFFFFFFFFFFFFFCh
cmp r10, rsi
jbe short loc_2D768
lea r9, [rsi+3]
and r9, 0FFFFFFFFFFFFFFFCh
loc_2D74C:
mov rdx, rdi
mov r11b, [rdi-1]
cmp rdi, r10
jbe loc_2D7E8
lea rdi, [rdx-1]
cmp r11b, 20h ; ' '
jz short loc_2D74C
jmp short loc_2D76B
loc_2D768:
mov rdx, rdi
loc_2D76B:
mov rdi, rdx
cmp rdx, rsi
jbe short loc_2D77D
lea rdx, [rdi-1]
cmp byte ptr [rdi-1], 20h ; ' '
jz short loc_2D76B
loc_2D77D:
mov r9b, [rax+20h]
mov r11, rdi
sub r11, rsi
loc_2D787:
mov rdx, rdi
mov r10, r11
cmp rdi, rsi
jbe short loc_2D7A4
lea rdi, [rdx-1]
movzx ebx, byte ptr [rdx-1]
lea r11, [r10-1]
cmp [rax+rbx], r9b
jz short loc_2D787
loc_2D7A4:
mov rdi, [rcx]
mov r9, [r8]
test r10, r10
jle short loc_2D7DF
loc_2D7AF:
mov r10d, edi
and r10d, 3Fh
add r10, r9
movzx r11d, byte ptr [rsi]
movzx r11d, byte ptr [rax+r11]
imul r11, r10
mov r10, rdi
shl r10, 8
add r10, r11
xor rdi, r10
add r9, 3
inc rsi
cmp rsi, rdx
jb short loc_2D7AF
loc_2D7DF:
mov [rcx], rdi
mov [r8], r9
pop rbx
pop rbp
retn
loc_2D7E8:
cmp r11b, 20h ; ' '
setnz dil
cmp r9, r10
setnb r10b
or r10b, dil
jnz loc_2D76B
mov rdi, rdx
loc_2D803:
mov rdx, rdi
cmp rdi, r9
jbe loc_2D76B
lea rdi, [rdx-4]
cmp dword ptr [rdx-4], 20202020h
jz short loc_2D803
jmp loc_2D76B
| long long my_hash_sort_simple(long long a1, unsigned __int8 *a2, unsigned long long a3, long long *a4, long long *a5)
{
long long result; // rax
unsigned long long v6; // rdi
unsigned long long v7; // r10
unsigned long long v8; // r9
unsigned __int8 *v9; // rdx
char v10; // r11
long long v11; // r11
unsigned long long v12; // rdx
long long v13; // r10
long long v14; // rdi
long long v15; // r9
result = *(_QWORD *)(a1 + 88);
v6 = (unsigned long long)&a2[a3];
if ( a3 >= 0x11 )
{
if ( a3 < 0x15 || (v7 = v6 & 0xFFFFFFFFFFFFFFFCLL, (v6 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v9 = &a2[a3];
}
else
{
v8 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v9 = (unsigned __int8 *)v6;
v10 = *(_BYTE *)(v6 - 1);
if ( v6 <= v7 )
break;
--v6;
if ( v10 != 32 )
goto LABEL_9;
}
if ( v10 == 32 && v8 < v7 )
{
do
{
v9 = (unsigned __int8 *)v6;
if ( v6 <= v8 )
break;
v6 -= 4LL;
}
while ( *((_DWORD *)v9 - 1) == 538976288 );
}
}
do
{
LABEL_9:
v6 = (unsigned long long)v9;
if ( v9 <= a2 )
break;
--v9;
}
while ( *(_BYTE *)(v6 - 1) == 32 );
}
v11 = v6 - (_QWORD)a2;
do
{
v12 = v6;
v13 = v11;
if ( v6 <= (unsigned long long)a2 )
break;
--v6;
--v11;
}
while ( *(_BYTE *)(result + *(unsigned __int8 *)(v12 - 1)) == *(_BYTE *)(result + 32) );
v14 = *a4;
v15 = *a5;
if ( v13 > 0 )
{
do
{
v14 ^= (v15 + (v14 & 0x3F)) * *(unsigned __int8 *)(result + *a2) + (v14 << 8);
v15 += 3LL;
++a2;
}
while ( (unsigned long long)a2 < v12 );
}
*a4 = v14;
*a5 = v15;
return result;
}
| my_hash_sort_simple:
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV RAX,qword ptr [RDI + 0x58]
LEA RDI,[RSI + RDX*0x1]
CMP RDX,0x11
JC 0x0012d77d
CMP RDX,0x15
JC 0x0012d768
MOV R10,RDI
AND R10,-0x4
CMP R10,RSI
JBE 0x0012d768
LEA R9,[RSI + 0x3]
AND R9,-0x4
LAB_0012d74c:
MOV RDX,RDI
MOV R11B,byte ptr [RDI + -0x1]
CMP RDI,R10
JBE 0x0012d7e8
LEA RDI,[RDX + -0x1]
CMP R11B,0x20
JZ 0x0012d74c
JMP 0x0012d76b
LAB_0012d768:
MOV RDX,RDI
LAB_0012d76b:
MOV RDI,RDX
CMP RDX,RSI
JBE 0x0012d77d
LEA RDX,[RDI + -0x1]
CMP byte ptr [RDI + -0x1],0x20
JZ 0x0012d76b
LAB_0012d77d:
MOV R9B,byte ptr [RAX + 0x20]
MOV R11,RDI
SUB R11,RSI
LAB_0012d787:
MOV RDX,RDI
MOV R10,R11
CMP RDI,RSI
JBE 0x0012d7a4
LEA RDI,[RDX + -0x1]
MOVZX EBX,byte ptr [RDX + -0x1]
LEA R11,[R10 + -0x1]
CMP byte ptr [RAX + RBX*0x1],R9B
JZ 0x0012d787
LAB_0012d7a4:
MOV RDI,qword ptr [RCX]
MOV R9,qword ptr [R8]
TEST R10,R10
JLE 0x0012d7df
LAB_0012d7af:
MOV R10D,EDI
AND R10D,0x3f
ADD R10,R9
MOVZX R11D,byte ptr [RSI]
MOVZX R11D,byte ptr [RAX + R11*0x1]
IMUL R11,R10
MOV R10,RDI
SHL R10,0x8
ADD R10,R11
XOR RDI,R10
ADD R9,0x3
INC RSI
CMP RSI,RDX
JC 0x0012d7af
LAB_0012d7df:
MOV qword ptr [RCX],RDI
MOV qword ptr [R8],R9
POP RBX
POP RBP
RET
LAB_0012d7e8:
CMP R11B,0x20
SETNZ DIL
CMP R9,R10
SETNC R10B
OR R10B,DIL
JNZ 0x0012d76b
MOV RDI,RDX
LAB_0012d803:
MOV RDX,RDI
CMP RDI,R9
JBE 0x0012d76b
LEA RDI,[RDX + -0x4]
CMP dword ptr [RDX + -0x4],0x20202020
JZ 0x0012d803
JMP 0x0012d76b
|
void my_hash_sort_simple(long param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
byte *pbVar3;
ulong uVar4;
byte *pbVar5;
long lVar6;
byte *pbVar7;
long lVar8;
lVar2 = *(long *)(param_1 + 0x58);
pbVar5 = param_2 + param_3;
if (param_3 < 0x11) goto LAB_0012d77d;
pbVar3 = pbVar5;
if ((0x14 < param_3) && (pbVar7 = (byte *)((ulong)pbVar5 & 0xfffffffffffffffc), param_2 < pbVar7))
{
do {
pbVar1 = pbVar5 + -1;
pbVar3 = pbVar5;
if (pbVar5 <= pbVar7) {
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar7 && *pbVar1 == 0x20)
goto LAB_0012d803;
break;
}
pbVar5 = pbVar5 + -1;
} while (*pbVar1 == 0x20);
}
goto LAB_0012d76b;
while (pbVar7 = pbVar5 + -4, pbVar5 = pbVar5 + -4, *(int *)pbVar7 == 0x20202020) {
LAB_0012d803:
pbVar3 = pbVar5;
if (pbVar5 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_0012d76b:
do {
pbVar5 = pbVar3;
if (pbVar5 <= param_2) break;
pbVar3 = pbVar5 + -1;
} while (pbVar5[-1] == 0x20);
LAB_0012d77d:
lVar6 = (long)pbVar5 - (long)param_2;
do {
lVar8 = lVar6;
pbVar3 = pbVar5;
if (pbVar3 <= param_2) break;
pbVar5 = pbVar3 + -1;
lVar6 = lVar8 + -1;
} while (*(char *)(lVar2 + (ulong)pbVar3[-1]) == *(char *)(lVar2 + 0x20));
uVar4 = *param_4;
lVar6 = *param_5;
if (0 < lVar8) {
do {
uVar4 = uVar4 ^ uVar4 * 0x100 +
(ulong)*(byte *)(lVar2 + (ulong)*param_2) *
((ulong)((uint)uVar4 & 0x3f) + lVar6);
lVar6 = lVar6 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar3);
}
*param_4 = uVar4;
*param_5 = lVar6;
return;
}
| |
51,253 | size_to_tail_pattern | eloqsql/storage/maria/ma_bitmap.c | static uint size_to_tail_pattern(MARIA_FILE_BITMAP *bitmap, uint size)
{
if (size <= bitmap->sizes[6])
return 6;
if (size <= bitmap->sizes[5])
return 5;
DBUG_ASSERT(size <= bitmap->sizes[0]);
return 0;
} | O0 | c | size_to_tail_pattern:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x120(%rcx), %eax
ja 0x40783
movl $0x6, -0x4(%rbp)
jmp 0x407a6
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x11c(%rcx), %eax
ja 0x4079b
movl $0x5, -0x4(%rbp)
jmp 0x407a6
jmp 0x4079d
jmp 0x4079f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| size_to_tail_pattern:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov eax, [rbp+var_14]
mov rcx, [rbp+var_10]
cmp eax, [rcx+120h]
ja short loc_40783
mov [rbp+var_4], 6
jmp short loc_407A6
loc_40783:
mov eax, [rbp+var_14]
mov rcx, [rbp+var_10]
cmp eax, [rcx+11Ch]
ja short loc_4079B
mov [rbp+var_4], 5
jmp short loc_407A6
loc_4079B:
jmp short $+2
loc_4079D:
jmp short $+2
loc_4079F:
mov [rbp+var_4], 0
loc_407A6:
mov eax, [rbp+var_4]
pop rbp
retn
| long long size_to_tail_pattern(long long a1, unsigned int a2)
{
if ( a2 > *(_DWORD *)(a1 + 288) )
{
if ( a2 > *(_DWORD *)(a1 + 284) )
return 0;
else
return 5;
}
else
{
return 6;
}
}
| size_to_tail_pattern:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x120]
JA 0x00140783
MOV dword ptr [RBP + -0x4],0x6
JMP 0x001407a6
LAB_00140783:
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x11c]
JA 0x0014079b
MOV dword ptr [RBP + -0x4],0x5
JMP 0x001407a6
LAB_0014079b:
JMP 0x0014079d
LAB_0014079d:
JMP 0x0014079f
LAB_0014079f:
MOV dword ptr [RBP + -0x4],0x0
LAB_001407a6:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 size_to_tail_pattern(long param_1,uint param_2)
{
int4 local_c;
if (*(uint *)(param_1 + 0x120) < param_2) {
if (*(uint *)(param_1 + 0x11c) < param_2) {
local_c = 0;
}
else {
local_c = 5;
}
}
else {
local_c = 6;
}
return local_c;
}
| |
51,254 | CLI::detail::valid_name_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | MikePodsytnik[P]TCRtrie/build_O0/_deps/cli11-src/include/CLI/impl/StringTools_inl.hpp | CLI11_INLINE bool valid_name_string(const std::string &str) {
if(str.empty() || !valid_first_char(str[0])) {
return false;
}
auto e = str.end();
for(auto c = str.begin() + 1; c != e; ++c)
if(!valid_later_char(*c))
return false;
return true;
} | O0 | cpp | CLI::detail::valid_name_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x99c0
testb $0x1, %al
jne 0x2ef32
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x96c0
movsbl (%rax), %edi
callq 0x2ed90
testb $0x1, %al
jne 0x2ef38
movb $0x0, -0x1(%rbp)
jmp 0x2efa3
movq -0x10(%rbp), %rdi
callq 0x9ac0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95b0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x22ae0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2f770
testb $0x1, %al
jne 0x2ef77
jmp 0x2ef9f
leaq -0x20(%rbp), %rdi
callq 0x230e0
movsbl (%rax), %edi
callq 0x2f7b0
testb $0x1, %al
jne 0x2ef92
movb $0x0, -0x1(%rbp)
jmp 0x2efa3
jmp 0x2ef94
leaq -0x20(%rbp), %rdi
callq 0x23050
jmp 0x2ef64
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
| _ZN3CLI6detail17valid_name_stringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_2EF32
mov rdi, [rbp+var_10]
xor eax, eax
mov esi, eax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movsx edi, byte ptr [rax]
call _ZN3CLI6detail16valid_first_charIcEEbT_; CLI::detail::valid_first_char<char>(char)
test al, 1
jnz short loc_2EF38
loc_2EF32:
mov [rbp+var_1], 0
jmp short loc_2EFA3
loc_2EF38:
mov rdi, [rbp+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov [rbp+var_18], rax
mov rdi, [rbp+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rbp+var_28], rax
lea rdi, [rbp+var_28]
mov esi, 1
call _ZNK9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEplEl; __gnu_cxx::__normal_iterator<char const*,std::string>::operator+(long)
mov [rbp+var_20], rax
loc_2EF64:
lea rdi, [rbp+var_20]
lea rsi, [rbp+var_18]
call _ZN9__gnu_cxxneIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESE_; __gnu_cxx::operator!=<char const*,std::string>(__gnu_cxx::__normal_iterator<char const*,std::string> const&,__gnu_cxx::__normal_iterator<char const*,std::string> const&)
test al, 1
jnz short loc_2EF77
jmp short loc_2EF9F
loc_2EF77:
lea rdi, [rbp+var_20]
call _ZNK9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char const*,std::string>::operator*(void)
movsx edi, byte ptr [rax]
call _ZN3CLI6detail16valid_later_charIcEEbT_; CLI::detail::valid_later_char<char>(char)
test al, 1
jnz short loc_2EF92
mov [rbp+var_1], 0
jmp short loc_2EFA3
loc_2EF92:
jmp short $+2
loc_2EF94:
lea rdi, [rbp+var_20]
call _ZN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEv; __gnu_cxx::__normal_iterator<char const*,std::string>::operator++(void)
jmp short loc_2EF64
loc_2EF9F:
mov [rbp+var_1], 1
loc_2EFA3:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
| char CLI::detail::valid_name_string(long long a1)
{
char *v1; // rax
char *v2; // rax
long long v4; // [rsp+8h] [rbp-28h] BYREF
long long i; // [rsp+10h] [rbp-20h] BYREF
long long v6; // [rsp+18h] [rbp-18h] BYREF
long long v7; // [rsp+20h] [rbp-10h]
v7 = a1;
if ( (std::string::empty(a1) & 1) != 0 )
return 0;
v1 = (char *)std::string::operator[](v7, 0LL);
if ( !CLI::detail::valid_first_char<char>(*v1) )
return 0;
v6 = std::string::end(v7);
v4 = std::string::begin(v7);
for ( i = __gnu_cxx::__normal_iterator<char const*,std::string>::operator+(&v4, 1LL);
(__gnu_cxx::operator!=<char const*,std::string>(&i, &v6) & 1) != 0;
__gnu_cxx::__normal_iterator<char const*,std::string>::operator++(&i) )
{
v2 = (char *)__gnu_cxx::__normal_iterator<char const*,std::string>::operator*((long long)&i);
if ( (CLI::detail::valid_later_char<char>((unsigned int)*v2) & 1) == 0 )
return 0;
}
return 1;
}
| valid_name_string:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001099c0
TEST AL,0x1
JNZ 0x0012ef32
MOV RDI,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001096c0
MOVSX EDI,byte ptr [RAX]
CALL 0x0012ed90
TEST AL,0x1
JNZ 0x0012ef38
LAB_0012ef32:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0012efa3
LAB_0012ef38:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00109ac0
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001095b0
MOV qword ptr [RBP + -0x28],RAX
LEA RDI,[RBP + -0x28]
MOV ESI,0x1
CALL 0x00122ae0
MOV qword ptr [RBP + -0x20],RAX
LAB_0012ef64:
LEA RDI,[RBP + -0x20]
LEA RSI,[RBP + -0x18]
CALL 0x0012f770
TEST AL,0x1
JNZ 0x0012ef77
JMP 0x0012ef9f
LAB_0012ef77:
LEA RDI,[RBP + -0x20]
CALL 0x001230e0
MOVSX EDI,byte ptr [RAX]
CALL 0x0012f7b0
TEST AL,0x1
JNZ 0x0012ef92
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0012efa3
LAB_0012ef92:
JMP 0x0012ef94
LAB_0012ef94:
LEA RDI,[RBP + -0x20]
CALL 0x00123050
JMP 0x0012ef64
LAB_0012ef9f:
MOV byte ptr [RBP + -0x1],0x1
LAB_0012efa3:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x30
POP RBP
RET
|
/* CLI::detail::valid_name_string(std::__cxx11::string const&) */
int1 CLI::detail::valid_name_string(string *param_1)
{
bool bVar1;
ulong uVar2;
char *pcVar3;
int8 local_30;
int8 local_28;
int8 local_20;
string *local_18;
local_18 = param_1;
uVar2 = std::__cxx11::string::empty();
if ((uVar2 & 1) == 0) {
pcVar3 = (char *)std::__cxx11::string::operator[]((ulong)local_18);
bVar1 = valid_first_char<char>(*pcVar3);
if (bVar1) {
local_20 = std::__cxx11::string::end();
local_30 = std::__cxx11::string::begin();
local_28 = __gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::operator+
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_30,1);
while( true ) {
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_28,(__normal_iterator *)&local_20)
;
if (!bVar1) {
return 1;
}
pcVar3 = (char *)__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::operator*
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_28
);
bVar1 = valid_later_char<char>(*pcVar3);
if (!bVar1) break;
__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::operator++
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_28);
}
return 0;
}
}
return 0;
}
| |
51,255 | minja::Value::operator<(minja::Value const&) const | monkey531[P]llama/common/minja.hpp | bool operator<(const Value & other) const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_number() && other.is_number()) return get<double>() < other.get<double>();
if (is_string() && other.is_string()) return get<std::string>() < other.get<std::string>();
throw std::runtime_error("Cannot compare values: " + dump() + " < " + other.dump());
} | O1 | cpp | minja::Value::operator<(minja::Value const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x20(%rdi)
movb 0x40(%rdi), %al
jne 0x9c6cf
cmpq $0x0, 0x10(%r15)
jne 0x9c6cf
testb %al, %al
jne 0x9c6cf
cmpq $0x0, 0x30(%r15)
je 0x9c7cd
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0x9c707
movb 0x40(%r14), %cl
addb $-0x5, %cl
cmpb $0x2, %cl
ja 0x9c707
movq %r15, %rdi
callq 0x8b4aa
movsd %xmm0, 0x40(%rsp)
movq %r14, %rdi
callq 0x8b4aa
ucomisd 0x40(%rsp), %xmm0
seta %bl
jmp 0x9c7bd
cmpb $0x3, %al
jne 0x9c7ff
cmpb $0x3, 0x40(%r14)
jne 0x9c7ff
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x8c3ea
movq %rsp, %rdi
movq %r14, %rsi
callq 0x8c3ea
movq 0x28(%rsp), %r14
movq 0x8(%rsp), %r15
cmpq %r14, %r15
movq %r14, %rdx
cmovbq %r15, %rdx
testq %rdx, %rdx
je 0x9c75d
movq (%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x1b420
movl %eax, %ebx
jmp 0x9c75f
xorl %ebx, %ebx
testl %ebx, %ebx
jne 0x9c784
subq %r15, %r14
cmpq $-0x7fffffff, %r14 # imm = 0x80000001
movq $-0x80000000, %rbx # imm = 0x80000000
cmovgeq %r14, %rbx
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpq %rax, %rbx
cmovgeq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c79f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b910
shrl $0x1f, %ebx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c7bd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b910
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1b460
movq %rax, %rbx
leaq 0x59a41(%rip), %rsi # 0xf6222
movq %rax, %rdi
callq 0x1b340
movq 0x967f8(%rip), %rsi # 0x132fe8
movq 0x96761(%rip), %rdx # 0x132f58
movq %rbx, %rdi
callq 0x1bfb0
movl $0x10, %edi
callq 0x1b460
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x8b5e0
leaq 0x5a5ee(%rip), %rsi # 0xf6e15
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x7d493
leaq 0x5a5ed(%rip), %rsi # 0xf6e2d
leaq 0x88(%rsp), %rdi
callq 0x1c1a0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x9c86e
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x9c87a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x8b5e0
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
leaq 0x48(%rsp), %rdx
callq 0x7d503
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1beb0
xorl %ebp, %ebp
movq 0x96717(%rip), %rsi # 0x132fe8
movq 0x96680(%rip), %rdx # 0x132f58
movq %rbx, %rdi
callq 0x1bfb0
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c906
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0x9c906
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c929
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0x9c929
movq %rax, %r14
movb $0x1, %bpl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x9c947
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0x9c947
movq %rax, %r14
movb $0x1, %bpl
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c970
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0x9c970
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c993
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0x9c993
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
jne 0x9c99d
jmp 0x9c9c5
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b6a0
jmp 0x9c9c5
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c9c5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b910
movq %r14, %rdi
callq 0x1c030
nop
| _ZNK5minja5ValueltERKS0_:
push rbp
push r15
push r14
push rbx
sub rsp, 0A8h
mov r14, rsi
mov r15, rdi
cmp qword ptr [rdi+20h], 0
mov al, [rdi+40h]
jnz short loc_9C6CF
cmp qword ptr [r15+10h], 0
jnz short loc_9C6CF
test al, al
jnz short loc_9C6CF
cmp qword ptr [r15+30h], 0
jz loc_9C7CD
loc_9C6CF:
lea ecx, [rax-5]
cmp cl, 2
ja short loc_9C707
mov cl, [r14+40h]
add cl, 0FBh
cmp cl, 2
ja short loc_9C707
mov rdi, r15
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+0C8h+var_88], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
ucomisd xmm0, [rsp+0C8h+var_88]
setnbe bl
jmp loc_9C7BD
loc_9C707:
cmp al, 3
jnz loc_9C7FF
cmp byte ptr [r14+40h], 3
jnz loc_9C7FF
lea rdi, [rsp+0C8h+var_A8]
mov rsi, r15
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
mov rdi, rsp
mov rsi, r14
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
mov r14, [rsp+0C8h+var_A0]
mov r15, [rsp+0C8h+var_C0]
cmp r15, r14
mov rdx, r14
cmovb rdx, r15
test rdx, rdx
jz short loc_9C75D
mov rsi, [rsp+0C8h+var_C8]
mov rdi, [rsp+0C8h+var_A8]
call _memcmp
mov ebx, eax
jmp short loc_9C75F
loc_9C75D:
xor ebx, ebx
loc_9C75F:
test ebx, ebx
jnz short loc_9C784
sub r14, r15
cmp r14, 0FFFFFFFF80000001h
mov rbx, 0FFFFFFFF80000000h
cmovge rbx, r14
mov eax, 7FFFFFFFh
cmp rbx, rax
cmovge rbx, rax
loc_9C784:
lea rax, [rsp+0C8h+var_B8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9C79F
mov rsi, [rsp+0C8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9C79F:
shr ebx, 1Fh
lea rax, [rsp+0C8h+var_98]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9C7BD
mov rsi, [rsp+0C8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9C7BD:
mov eax, ebx
add rsp, 0A8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_9C7CD:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_9C7FF:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0C8h+var_60]
mov rsi, r15
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aCannotCompareV; "Cannot compare values: "
lea rdi, [rsp+0C8h+var_40]
lea rdx, [rsp+0C8h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rsi, asc_F6E2D; " < "
lea rdi, [rsp+0C8h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r15, [rsp+0C8h+var_B8]
mov [r15-10h], r15
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jnz short loc_9C86E
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r15], xmm0
jmp short loc_9C87A
loc_9C86E:
mov [rsp+0C8h+var_C8], rdx
mov rdx, [rcx]
mov [rsp+0C8h+var_B8], rdx
loc_9C87A:
mov rdx, [rax+8]
mov [rsp+0C8h+var_C0], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rdi, [rsp+0C8h+var_80]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rdi, [rsp+0C8h+var_A8]
mov rsi, rsp
lea rdx, [rsp+0C8h+var_80]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
mov bpl, 1
lea rsi, [rsp+0C8h+var_A8]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+0C8h+var_98]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9C906
mov rsi, [rsp+0C8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9C906
mov r14, rax
mov bpl, 1
loc_9C906:
lea rax, [rsp+0C8h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9C929
mov rsi, [rsp+0C8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9C929
mov r14, rax
mov bpl, 1
loc_9C929:
mov rdi, [rsp+0C8h+var_C8]; void *
cmp rdi, r15
jz short loc_9C947
mov rsi, [rsp+0C8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9C947
mov r14, rax
mov bpl, 1
loc_9C947:
lea rax, [rsp+0C8h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9C970
mov rsi, [rsp+0C8h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9C970
mov r14, rax
mov bpl, 1
loc_9C970:
lea rax, [rsp+0C8h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9C993
mov rsi, [rsp+0C8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9C993
mov r14, rax
mov bpl, 1
loc_9C993:
test bpl, bpl
jnz short loc_9C99D
jmp short loc_9C9C5
mov r14, rax
loc_9C99D:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_9C9C5
mov r14, rax
lea rax, [rsp+0C8h+var_98]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9C9C5
mov rsi, [rsp+0C8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9C9C5:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::operator<(long long a1, long long a2)
{
unsigned int v2; // ebx
char v3; // al
unsigned long long v4; // r14
unsigned long long v5; // r15
unsigned long long v6; // rdx
long long v7; // rbx
long long v8; // r14
std::runtime_error *exception; // rbx
void *v11; // rbx
long long v12; // rax
__int128 *v13; // rcx
void *v14; // [rsp+0h] [rbp-C8h] BYREF
unsigned long long v15; // [rsp+8h] [rbp-C0h]
__int128 v16; // [rsp+10h] [rbp-B8h] BYREF
long long *v17; // [rsp+20h] [rbp-A8h] BYREF
unsigned long long v18; // [rsp+28h] [rbp-A0h]
long long v19; // [rsp+30h] [rbp-98h] BYREF
double v20; // [rsp+40h] [rbp-88h]
_QWORD v21[2]; // [rsp+48h] [rbp-80h] BYREF
_BYTE v22[16]; // [rsp+68h] [rbp-60h] BYREF
_BYTE v23[16]; // [rsp+88h] [rbp-40h] BYREF
v3 = *(_BYTE *)(a1 + 64);
if ( !*(_QWORD *)(a1 + 32) && !*(_QWORD *)(a1 + 16) && !v3 && !*(_QWORD *)(a1 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( (unsigned __int8)(v3 - 5) > 2u || (unsigned __int8)(*(_BYTE *)(a2 + 64) - 5) > 2u )
{
if ( v3 != 3 || *(_BYTE *)(a2 + 64) != 3 )
{
v11 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v22, a1, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v23, (long long)"Cannot compare values: ", (long long)v22);
v12 = std::string::append(v23, " < ");
v14 = &v16;
v13 = (__int128 *)(v12 + 16);
if ( *(_QWORD *)v12 == v12 + 16 )
{
v16 = *v13;
}
else
{
v14 = *(void **)v12;
*(_QWORD *)&v16 = *(_QWORD *)v13;
}
v15 = *(_QWORD *)(v12 + 8);
*(_QWORD *)v12 = v13;
*(_QWORD *)(v12 + 8) = 0LL;
*(_BYTE *)(v12 + 16) = 0;
minja::Value::dump[abi:cxx11]((long long)v21, a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)&v17, &v14, v21);
std::runtime_error::runtime_error(v11, &v17);
__cxa_throw(
v11,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Value::get<std::string>((long long)&v17, (_QWORD *)a1);
minja::Value::get<std::string>((long long)&v14, (_QWORD *)a2);
v4 = v18;
v5 = v15;
v6 = v18;
if ( v15 < v18 )
v6 = v15;
if ( v6 )
LODWORD(v7) = memcmp(v17, v14);
else
LODWORD(v7) = 0;
if ( !(_DWORD)v7 )
{
v8 = v4 - v5;
v7 = 0xFFFFFFFF80000000LL;
if ( v8 >= -2147483647 )
v7 = v8;
if ( v7 >= 0x7FFFFFFF )
LODWORD(v7) = 0x7FFFFFFF;
}
if ( v14 != &v16 )
operator delete(v14, v16 + 1);
v2 = (unsigned int)v7 >> 31;
if ( v17 != &v19 )
operator delete(v17, v19 + 1);
}
else
{
v20 = minja::Value::get<double>(a1);
LOBYTE(v2) = minja::Value::get<double>(a2) > v20;
}
return v2;
}
| operator<:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV R14,RSI
MOV R15,RDI
CMP qword ptr [RDI + 0x20],0x0
MOV AL,byte ptr [RDI + 0x40]
JNZ 0x0019c6cf
CMP qword ptr [R15 + 0x10],0x0
JNZ 0x0019c6cf
TEST AL,AL
JNZ 0x0019c6cf
CMP qword ptr [R15 + 0x30],0x0
JZ 0x0019c7cd
LAB_0019c6cf:
LEA ECX,[RAX + -0x5]
CMP CL,0x2
JA 0x0019c707
MOV CL,byte ptr [R14 + 0x40]
ADD CL,0xfb
CMP CL,0x2
JA 0x0019c707
MOV RDI,R15
CALL 0x0018b4aa
MOVSD qword ptr [RSP + 0x40],XMM0
MOV RDI,R14
CALL 0x0018b4aa
UCOMISD XMM0,qword ptr [RSP + 0x40]
SETA BL
JMP 0x0019c7bd
LAB_0019c707:
CMP AL,0x3
JNZ 0x0019c7ff
CMP byte ptr [R14 + 0x40],0x3
JNZ 0x0019c7ff
LEA RDI,[RSP + 0x20]
MOV RSI,R15
CALL 0x0018c3ea
LAB_0019c727:
MOV RDI,RSP
MOV RSI,R14
CALL 0x0018c3ea
LAB_0019c732:
MOV R14,qword ptr [RSP + 0x28]
MOV R15,qword ptr [RSP + 0x8]
CMP R15,R14
MOV RDX,R14
CMOVC RDX,R15
TEST RDX,RDX
JZ 0x0019c75d
MOV RSI,qword ptr [RSP]
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0011b420
MOV EBX,EAX
JMP 0x0019c75f
LAB_0019c75d:
XOR EBX,EBX
LAB_0019c75f:
TEST EBX,EBX
JNZ 0x0019c784
SUB R14,R15
CMP R14,-0x7fffffff
MOV RBX,-0x80000000
CMOVGE RBX,R14
MOV EAX,0x7fffffff
CMP RBX,RAX
CMOVGE RBX,RAX
LAB_0019c784:
LEA RAX,[RSP + 0x10]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0019c79f
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011b910
LAB_0019c79f:
SHR EBX,0x1f
LEA RAX,[RSP + 0x30]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0019c7bd
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011b910
LAB_0019c7bd:
MOV EAX,EBX
ADD RSP,0xa8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0019c7cd:
MOV EDI,0x10
CALL 0x0011b460
MOV RBX,RAX
LAB_0019c7da:
LEA RSI,[0x1f6222]
MOV RDI,RAX
CALL 0x0011b340
LAB_0019c7e9:
MOV RSI,qword ptr [0x00232fe8]
MOV RDX,qword ptr [0x00232f58]
MOV RDI,RBX
CALL 0x0011bfb0
LAB_0019c7ff:
MOV EDI,0x10
CALL 0x0011b460
MOV RBX,RAX
LAB_0019c80c:
LEA RDI,[RSP + 0x68]
MOV RSI,R15
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0018b5e0
LAB_0019c820:
LEA RSI,[0x1f6e15]
LEA RDI,[RSP + 0x88]
LEA RDX,[RSP + 0x68]
CALL 0x0017d493
LAB_0019c839:
LEA RSI,[0x1f6e2d]
LEA RDI,[RSP + 0x88]
CALL 0x0011c1a0
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JNZ 0x0019c86e
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R15],XMM0
JMP 0x0019c87a
LAB_0019c86e:
MOV qword ptr [RSP],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x10],RDX
LAB_0019c87a:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_0019c892:
LEA RDI,[RSP + 0x48]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0018b5e0
LAB_0019c8a6:
LEA RDI,[RSP + 0x20]
MOV RSI,RSP
LEA RDX,[RSP + 0x48]
CALL 0x0017d503
MOV BPL,0x1
LAB_0019c8bb:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x0011beb0
XOR EBP,EBP
MOV RSI,qword ptr [0x00232fe8]
MOV RDX,qword ptr [0x00232f58]
MOV RDI,RBX
CALL 0x0011bfb0
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
ulong __thiscall minja::Value::operator<(Value *this,Value *param_1)
{
Value VVar1;
double dVar2;
uint uVar3;
runtime_error *prVar4;
long *plVar5;
long *plVar6;
ulong uVar7;
int8 unaff_RBX;
long *local_c8;
ulong local_c0;
long local_b8;
long lStack_b0;
long *local_a8;
ulong local_a0;
long local_98 [2];
double local_88;
int1 local_80 [32];
int1 local_60 [32];
char local_40 [32];
VVar1 = this[0x40];
if ((((*(long *)(this + 0x20) == 0) && (*(long *)(this + 0x10) == 0)) && (VVar1 == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019c7da to 0019c7e8 has its CatchHandler @ 0019c99a */
std::runtime_error::runtime_error(prVar4,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00232fe8,PTR__runtime_error_00232f58);
}
if (((byte)((char)VVar1 - 5U) < 3) && ((byte)((char)param_1[0x40] - 5U) < 3)) {
local_88 = get<double>(this);
dVar2 = get<double>(param_1);
uVar7 = CONCAT71((int7)((ulong)unaff_RBX >> 8),local_88 < dVar2);
}
else {
if ((VVar1 != (Value)0x3) || (param_1[0x40] != (Value)0x3)) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019c80c to 0019c81f has its CatchHandler @ 0019c98d */
dump_abi_cxx11_((int)local_60,SUB81(this,0));
/* try { // try from 0019c820 to 0019c838 has its CatchHandler @ 0019c96a */
std::operator+(local_40,(string *)"Cannot compare values: ");
/* try { // try from 0019c839 to 0019c84c has its CatchHandler @ 0019c941 */
plVar5 = (long *)std::__cxx11::string::append(local_40);
local_c8 = (long *)*plVar5;
plVar6 = plVar5 + 2;
if (local_c8 == plVar6) {
local_b8 = *plVar6;
lStack_b0 = plVar5[3];
local_c8 = &local_b8;
}
else {
local_b8 = *plVar6;
}
local_c0 = plVar5[1];
*plVar5 = (long)plVar6;
plVar5[1] = 0;
*(int1 *)(plVar5 + 2) = 0;
/* try { // try from 0019c892 to 0019c8a5 has its CatchHandler @ 0019c923 */
dump_abi_cxx11_((int)local_80,SUB81(param_1,0));
/* try { // try from 0019c8a6 to 0019c8b7 has its CatchHandler @ 0019c900 */
std::operator+((string *)&local_a8,(string *)&local_c8);
/* try { // try from 0019c8bb to 0019c8df has its CatchHandler @ 0019c8e0 */
std::runtime_error::runtime_error(prVar4,(string *)&local_a8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00232fe8,PTR__runtime_error_00232f58);
}
get<std::__cxx11::string>();
/* try { // try from 0019c727 to 0019c731 has its CatchHandler @ 0019c9a7 */
get<std::__cxx11::string>();
uVar7 = local_a0;
if (local_c0 < local_a0) {
uVar7 = local_c0;
}
if (uVar7 == 0) {
uVar7 = 0;
}
else {
uVar3 = memcmp(local_a8,local_c8,uVar7);
uVar7 = (ulong)uVar3;
}
if ((int)uVar7 == 0) {
uVar7 = 0xffffffff80000000;
if (-0x80000000 < (long)(local_a0 - local_c0)) {
uVar7 = local_a0 - local_c0;
}
if (0x7ffffffe < (long)uVar7) {
uVar7 = 0;
}
}
if (local_c8 != &local_b8) {
operator_delete(local_c8,local_b8 + 1);
}
uVar7 = uVar7 >> 0x1f & 1;
if (local_a8 != local_98) {
operator_delete(local_a8,local_98[0] + 1);
}
}
return uVar7 & 0xffffffff;
}
| |
51,256 | ggml_are_same_layout(ggml_tensor const*, ggml_tensor const*) | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | static bool ggml_are_same_layout(const struct ggml_tensor * a, const struct ggml_tensor * b) {
if (a->type != b->type) {
return false;
}
for (int i = 0; i < GGML_MAX_DIMS; i++) {
if (a->ne[i] != b->ne[i]) {
return false;
}
if (a->nb[i] != b->nb[i]) {
return false;
}
}
return true;
} | O0 | cpp | ggml_are_same_layout(ggml_tensor const*, ggml_tensor const*):
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x5eb20
movb $0x0, -0x1(%rbp)
jmp 0x5eb82
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x5eb7e
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpq 0x10(%rcx,%rdx,8), %rax
je 0x5eb4f
movb $0x0, -0x1(%rbp)
jmp 0x5eb82
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpq 0x30(%rcx,%rdx,8), %rax
je 0x5eb71
movb $0x0, -0x1(%rbp)
jmp 0x5eb82
jmp 0x5eb73
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5eb27
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
| _ZL20ggml_are_same_layoutPK11ggml_tensorS1_:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_18]
cmp eax, [rcx]
jz short loc_5EB20
mov [rbp+var_1], 0
jmp short loc_5EB82
loc_5EB20:
mov [rbp+var_1C], 0
loc_5EB27:
cmp [rbp+var_1C], 4
jge short loc_5EB7E
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
mov rax, [rax+rcx*8+10h]
mov rcx, [rbp+var_18]
movsxd rdx, [rbp+var_1C]
cmp rax, [rcx+rdx*8+10h]
jz short loc_5EB4F
mov [rbp+var_1], 0
jmp short loc_5EB82
loc_5EB4F:
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
mov rax, [rax+rcx*8+30h]
mov rcx, [rbp+var_18]
movsxd rdx, [rbp+var_1C]
cmp rax, [rcx+rdx*8+30h]
jz short loc_5EB71
mov [rbp+var_1], 0
jmp short loc_5EB82
loc_5EB71:
jmp short $+2
loc_5EB73:
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_5EB27
loc_5EB7E:
mov [rbp+var_1], 1
loc_5EB82:
mov al, [rbp+var_1]
and al, 1
pop rbp
retn
| char ggml_are_same_layout(_DWORD *a1, _DWORD *a2)
{
int i; // [rsp+0h] [rbp-1Ch]
if ( *a1 != *a2 )
return 0;
for ( i = 0; i < 4; ++i )
{
if ( *(_QWORD *)&a1[2 * i + 4] != *(_QWORD *)&a2[2 * i + 4] )
return 0;
if ( *(_QWORD *)&a1[2 * i + 12] != *(_QWORD *)&a2[2 * i + 12] )
return 0;
}
return 1;
}
| ggml_are_same_layout:
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]
MOV RCX,qword ptr [RBP + -0x18]
CMP EAX,dword ptr [RCX]
JZ 0x0015eb20
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0015eb82
LAB_0015eb20:
MOV dword ptr [RBP + -0x1c],0x0
LAB_0015eb27:
CMP dword ptr [RBP + -0x1c],0x4
JGE 0x0015eb7e
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x10]
MOV RCX,qword ptr [RBP + -0x18]
MOVSXD RDX,dword ptr [RBP + -0x1c]
CMP RAX,qword ptr [RCX + RDX*0x8 + 0x10]
JZ 0x0015eb4f
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0015eb82
LAB_0015eb4f:
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x30]
MOV RCX,qword ptr [RBP + -0x18]
MOVSXD RDX,dword ptr [RBP + -0x1c]
CMP RAX,qword ptr [RCX + RDX*0x8 + 0x30]
JZ 0x0015eb71
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0015eb82
LAB_0015eb71:
JMP 0x0015eb73
LAB_0015eb73:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0015eb27
LAB_0015eb7e:
MOV byte ptr [RBP + -0x1],0x1
LAB_0015eb82:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
POP RBP
RET
|
/* ggml_are_same_layout(ggml_tensor const*, ggml_tensor const*) */
int8 ggml_are_same_layout(ggml_tensor *param_1,ggml_tensor *param_2)
{
ulong uVar1;
uint local_24;
int1 local_9;
uVar1 = (ulong)*(uint *)param_1;
if (*(uint *)param_1 == *(uint *)param_2) {
local_24 = 0;
while ((int)local_24 < 4) {
uVar1 = *(ulong *)(param_1 + (long)(int)local_24 * 8 + 0x10);
if (uVar1 != *(ulong *)(param_2 + (long)(int)local_24 * 8 + 0x10)) {
local_9 = 0;
goto LAB_0015eb82;
}
uVar1 = *(ulong *)(param_1 + (long)(int)local_24 * 8 + 0x30);
if (uVar1 != *(ulong *)(param_2 + (long)(int)local_24 * 8 + 0x30)) {
local_9 = 0;
goto LAB_0015eb82;
}
local_24 = local_24 + 1;
uVar1 = (ulong)local_24;
}
local_9 = 1;
}
else {
local_9 = 0;
}
LAB_0015eb82:
return CONCAT71((int7)(uVar1 >> 8),local_9);
}
| |
51,257 | ggml_are_same_layout(ggml_tensor const*, ggml_tensor const*) | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | static bool ggml_are_same_layout(const struct ggml_tensor * a, const struct ggml_tensor * b) {
if (a->type != b->type) {
return false;
}
for (int i = 0; i < GGML_MAX_DIMS; i++) {
if (a->ne[i] != b->ne[i]) {
return false;
}
if (a->nb[i] != b->nb[i]) {
return false;
}
}
return true;
} | O2 | cpp | ggml_are_same_layout(ggml_tensor const*, ggml_tensor const*):
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x2bc69
pushq $-0x20
popq %rcx
testq %rcx, %rcx
sete %al
je 0x2bc68
movq 0x30(%rdi,%rcx), %rdx
cmpq 0x30(%rsi,%rcx), %rdx
jne 0x2bc68
movq 0x50(%rdi,%rcx), %rdx
leaq 0x8(%rcx), %r8
cmpq 0x50(%rsi,%rcx), %rdx
movq %r8, %rcx
je 0x2bc41
retq
xorl %eax, %eax
retq
| _ZL20ggml_are_same_layoutPK11ggml_tensorS1_:
mov eax, [rdi]
cmp eax, [rsi]
jnz short loc_2BC69
push 0FFFFFFFFFFFFFFE0h
pop rcx
loc_2BC41:
test rcx, rcx
setz al
jz short locret_2BC68
mov rdx, [rdi+rcx+30h]
cmp rdx, [rsi+rcx+30h]
jnz short locret_2BC68
mov rdx, [rdi+rcx+50h]
lea r8, [rcx+8]
cmp rdx, [rsi+rcx+50h]
mov rcx, r8
jz short loc_2BC41
locret_2BC68:
retn
loc_2BC69:
xor eax, eax
retn
| bool ggml_are_same_layout(_DWORD *a1, _DWORD *a2)
{
long long v2; // rcx
bool result; // al
bool v4; // zf
if ( *a1 != *a2 )
return 0;
v2 = 0x3FFFFFFFFFFFFFF8LL;
do
{
result = v2 == 0;
if ( !(v2 * 4) )
break;
if ( *(_QWORD *)&a1[v2 + 12] != *(_QWORD *)&a2[v2 + 12] )
break;
v4 = *(_QWORD *)&a1[v2 + 20] == *(_QWORD *)&a2[v2 + 20];
v2 += 2LL;
}
while ( v4 );
return result;
}
| ggml_are_same_layout:
MOV EAX,dword ptr [RDI]
CMP EAX,dword ptr [RSI]
JNZ 0x0012bc69
PUSH -0x20
POP RCX
LAB_0012bc41:
TEST RCX,RCX
SETZ AL
JZ 0x0012bc68
MOV RDX,qword ptr [RDI + RCX*0x1 + 0x30]
CMP RDX,qword ptr [RSI + RCX*0x1 + 0x30]
JNZ 0x0012bc68
MOV RDX,qword ptr [RDI + RCX*0x1 + 0x50]
LEA R8,[RCX + 0x8]
CMP RDX,qword ptr [RSI + RCX*0x1 + 0x50]
MOV RCX,R8
JZ 0x0012bc41
LAB_0012bc68:
RET
LAB_0012bc69:
XOR EAX,EAX
RET
|
/* ggml_are_same_layout(ggml_tensor const*, ggml_tensor const*) */
ulong ggml_are_same_layout(ggml_tensor *param_1,ggml_tensor *param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
long lVar4;
uVar3 = (ulong)*(uint *)param_1;
if (*(uint *)param_1 != *(uint *)param_2) {
return 0;
}
lVar4 = -0x20;
while( true ) {
uVar3 = CONCAT71((int7)(uVar3 >> 8),lVar4 == 0);
if (lVar4 == 0) {
return uVar3;
}
if (*(long *)(param_1 + lVar4 + 0x30) != *(long *)(param_2 + lVar4 + 0x30)) break;
lVar1 = lVar4 + 0x50;
lVar2 = lVar4 + 0x50;
lVar4 = lVar4 + 8;
if (*(long *)(param_1 + lVar1) != *(long *)(param_2 + lVar2)) {
return uVar3;
}
}
return uVar3;
}
| |
51,258 | inline_mysql_file_write | eloqsql/include/mysql/psi/mysql_file.h | static inline size_t
inline_mysql_file_write(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, const uchar *buffer, size_t count, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_written;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_WRITE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_write(file, buffer, count, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_written= (result == 0) ? count : 0;
else
bytes_written= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_written);
return result;
}
#endif
result= my_write(file, buffer, count, flags);
return result;
} | O0 | c | inline_mysql_file_write:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x1e39f8(%rip), %rax # 0x2c75a0
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x7, %edx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%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 0xe3cb7
leaq 0x1e39ae(%rip), %rax # 0x2c75a0
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xfce50
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xe3c62
cmpq $0x0, -0x38(%rbp)
jne 0xe3c47
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0xe3c52
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0xe3c52
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0xe3c8f
cmpq $-0x1, -0x38(%rbp)
je 0xe3c76
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0xe3c81
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0xe3c81
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x1e390a(%rip), %rax # 0x2c75a0
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq *%rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe3cd7
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xfce50
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| inline_mysql_file_write_3:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_88]
mov edx, 7
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 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_E3CB7
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
call my_write
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
and rax, 6
cmp rax, 0
jz short loc_E3C62
cmp [rbp+var_38], 0
jnz short loc_E3C47
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
jmp short loc_E3C52
loc_E3C47:
xor eax, eax
mov [rbp+var_98], rax
jmp short $+2
loc_E3C52:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
jmp short loc_E3C8F
loc_E3C62:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_E3C76
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
jmp short loc_E3C81
loc_E3C76:
xor eax, eax
mov [rbp+var_A0], rax
jmp short $+2
loc_E3C81:
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
loc_E3C8F:
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_90]
call rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_E3CD7
loc_E3CB7:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
call my_write
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_E3CD7:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
| long long inline_mysql_file_write_3(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
long long a5,
long long a6)
{
long long v7; // [rsp+0h] [rbp-A0h]
long long v8; // [rsp+8h] [rbp-98h]
_BYTE v9[72]; // [rsp+18h] [rbp-88h] BYREF
long long v10; // [rsp+60h] [rbp-40h]
long long v11; // [rsp+68h] [rbp-38h]
long long v12; // [rsp+70h] [rbp-30h]
long long v13; // [rsp+78h] [rbp-28h]
long long v14; // [rsp+80h] [rbp-20h]
unsigned int v15; // [rsp+88h] [rbp-18h]
unsigned int v16; // [rsp+8Ch] [rbp-14h]
long long v17; // [rsp+90h] [rbp-10h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13 = a5;
v12 = a6;
v10 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v9, a3, 7LL);
if ( v10 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v10, v13, v17, v16);
v11 = my_write(v15, v14, v13, v12);
if ( (v12 & 6) != 0 )
{
if ( v11 )
v8 = 0LL;
else
v8 = v13;
((void ( *)(long long, long long))PSI_server[67])(v10, v8);
}
else
{
if ( v11 == -1 )
v7 = 0LL;
else
v7 = v11;
((void ( *)(long long, long long))PSI_server[67])(v10, v7);
}
return v11;
}
else
{
return my_write(v15, v14, v13, v12);
}
}
| inline_mysql_file_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3c75a0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x7
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],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 0x001e3cb7
LEA RAX,[0x3c75a0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001fce50
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001e3c62
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001e3c47
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001e3c52
LAB_001e3c47:
XOR EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001e3c52
LAB_001e3c52:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x001e3c8f
LAB_001e3c62:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001e3c76
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001e3c81
LAB_001e3c76:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001e3c81
LAB_001e3c81:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_001e3c8f:
LEA RAX,[0x3c75a0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x90]
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001e3cd7
LAB_001e3cb7:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001fce50
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001e3cd7:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
long inline_mysql_file_write
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
long param_5,ulong param_6)
{
long local_a8;
long local_a0;
long local_98;
int1 local_90 [72];
long local_48;
long local_40;
ulong local_38;
long local_30;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
long local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,7);
if (local_48 == 0) {
local_10 = my_write(local_20,local_28,local_30,local_38);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_30,local_18,local_1c);
local_40 = my_write(local_20,local_28,local_30,local_38);
if ((local_38 & 6) == 0) {
local_a8 = local_40;
if (local_40 == -1) {
local_a8 = 0;
}
local_98 = local_a8;
}
else {
if (local_40 == 0) {
local_a0 = local_30;
}
else {
local_a0 = 0;
}
local_98 = local_a0;
}
(**(code **)(PSI_server + 0x218))(local_48,local_98);
local_10 = local_40;
}
return local_10;
}
| |
51,259 | client_mpvio_read_packet | eloqsql/libmariadb/plugins/auth/my_auth.c | static int client_mpvio_read_packet(struct st_plugin_vio *mpv, uchar **buf)
{
MCPVIO_EXT *mpvio= (MCPVIO_EXT*)mpv;
MYSQL *mysql= mpvio->mysql;
ulong pkt_len;
/* there are cached data left, feed it to a plugin */
if (mpvio->cached_server_reply.pkt)
{
*buf= mpvio->cached_server_reply.pkt;
mpvio->cached_server_reply.pkt= 0;
mpvio->packets_read++;
return mpvio->cached_server_reply.pkt_len;
}
if (mpvio->packets_read == 0)
{
/*
the server handshake packet came from the wrong plugin,
or it's mysql_change_user(). Either way, there is no data
for a plugin to read. send a dummy packet to the server
to initiate a dialog.
*/
if (client_mpvio_write_packet(mpv, 0, 0))
return (int)packet_error;
}
/* otherwise read the data */
if ((pkt_len= ma_net_safe_read(mysql)) == packet_error)
return (int)packet_error;
mpvio->last_read_packet_len= pkt_len;
*buf= mysql->net.read_pos;
/* was it a request to change plugins ? */
if (pkt_len && **buf == 254)
return (int)packet_error; /* if yes, this plugin shan't continue */
/*
the server sends \1\255 or \1\254 instead of just \255 or \254 -
for us to not confuse it with an error or "change plugin" packets.
We remove this escaping \1 here.
See also server_mpvio_write_packet() where the escaping is done.
*/
if (pkt_len && **buf == 1)
{
(*buf)++;
pkt_len--;
}
mpvio->packets_read++;
return pkt_len;
} | O0 | c | client_mpvio_read_packet:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x431a6
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq -0x20(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x43277
movq -0x20(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x431d3
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x43280
cmpl $0x0, %eax
je 0x431d1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x43277
jmp 0x431d3
movq -0x28(%rbp), %rdi
callq 0x16920
movq %rax, -0x30(%rbp)
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jne 0x431f6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x43277
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x43233
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jne 0x43233
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x43277
cmpq $0x0, -0x30(%rbp)
je 0x43263
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x43263
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
| client_mpvio_read_packet:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rax, [rax+18h]
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
cmp qword ptr [rax+30h], 0
jz short loc_431A6
mov rax, [rbp+var_20]
mov rcx, [rax+30h]
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_20]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_20]
mov ecx, [rax+40h]
add ecx, 1
mov [rax+40h], ecx
mov rax, [rbp+var_20]
mov eax, [rax+38h]
mov [rbp+var_4], eax
jmp loc_43277
loc_431A6:
mov rax, [rbp+var_20]
cmp dword ptr [rax+40h], 0
jnz short loc_431D3
mov rdi, [rbp+var_10]
xor eax, eax
mov edx, eax
mov rsi, rdx
call client_mpvio_write_packet
cmp eax, 0
jz short loc_431D1
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_43277
loc_431D1:
jmp short $+2
loc_431D3:
mov rdi, [rbp+var_28]
call ma_net_safe_read
mov [rbp+var_30], rax
mov ecx, 0FFFFFFFFh
cmp rax, rcx
jnz short loc_431F6
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_43277
loc_431F6:
mov rax, [rbp+var_30]
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+4Ch], ecx
mov rax, [rbp+var_28]
mov rcx, [rax+20h]
mov rax, [rbp+var_18]
mov [rax], rcx
cmp [rbp+var_30], 0
jz short loc_43233
mov rax, [rbp+var_18]
mov rax, [rax]
movzx eax, byte ptr [rax]
cmp eax, 0FEh
jnz short loc_43233
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_43277
loc_43233:
cmp [rbp+var_30], 0
jz short loc_43263
mov rax, [rbp+var_18]
mov rax, [rax]
movzx eax, byte ptr [rax]
cmp eax, 1
jnz short loc_43263
mov rax, [rbp+var_18]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov rax, [rbp+var_30]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_30], rax
loc_43263:
mov rax, [rbp+var_20]
mov ecx, [rax+40h]
add ecx, 1
mov [rax+40h], ecx
mov rax, [rbp+var_30]
mov [rbp+var_4], eax
loc_43277:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long client_mpvio_read_packet(long long a1, _QWORD *a2, long long a3, long long a4, int a5, int a6)
{
long long v7; // [rsp+0h] [rbp-30h]
long long v8; // [rsp+8h] [rbp-28h]
_QWORD *v9; // [rsp+18h] [rbp-18h]
v9 = a2;
v8 = *(_QWORD *)(a1 + 24);
if ( *(_QWORD *)(a1 + 48) )
{
*a2 = *(_QWORD *)(a1 + 48);
*(_QWORD *)(a1 + 48) = 0LL;
++*(_DWORD *)(a1 + 64);
return *(unsigned int *)(a1 + 56);
}
else if ( *(_DWORD *)(a1 + 64) || (a2 = 0LL, !(unsigned int)client_mpvio_write_packet(a1, 0LL)) )
{
v7 = ma_net_safe_read(v8, (long long)a2, a3, a4, a5, a6);
if ( v7 == 0xFFFFFFFFLL )
{
return (unsigned int)-1;
}
else
{
*(_DWORD *)(a1 + 76) = v7;
*v9 = *(_QWORD *)(v8 + 32);
if ( v7 && *(unsigned __int8 *)*v9 == 254 )
{
return (unsigned int)-1;
}
else
{
if ( v7 && *(_BYTE *)*v9 == 1 )
{
++*v9;
LODWORD(v7) = v7 - 1;
}
++*(_DWORD *)(a1 + 64);
return (unsigned int)v7;
}
}
}
else
{
return (unsigned int)-1;
}
}
| client_mpvio_read_packet:
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 + -0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x30],0x0
JZ 0x001431a6
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x40]
ADD ECX,0x1
MOV dword ptr [RAX + 0x40],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x38]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00143277
LAB_001431a6:
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x40],0x0
JNZ 0x001431d3
MOV RDI,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV EDX,EAX
MOV RSI,RDX
CALL 0x00143280
CMP EAX,0x0
JZ 0x001431d1
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00143277
LAB_001431d1:
JMP 0x001431d3
LAB_001431d3:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00116920
MOV qword ptr [RBP + -0x30],RAX
MOV ECX,0xffffffff
CMP RAX,RCX
JNZ 0x001431f6
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00143277
LAB_001431f6:
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x4c],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00143233
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfe
JNZ 0x00143233
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00143277
LAB_00143233:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00143263
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x1
JNZ 0x00143263
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x30],RAX
LAB_00143263:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x40]
ADD ECX,0x1
MOV dword ptr [RAX + 0x40],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x4],EAX
LAB_00143277:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 client_mpvio_read_packet(long param_1,long *param_2)
{
long lVar1;
int iVar2;
long local_38;
int4 local_c;
lVar1 = *(long *)(param_1 + 0x18);
if (*(long *)(param_1 + 0x30) == 0) {
if ((*(int *)(param_1 + 0x40) == 0) &&
(iVar2 = client_mpvio_write_packet(param_1,0), iVar2 != 0)) {
local_c = 0xffffffff;
}
else {
local_38 = ma_net_safe_read(lVar1);
if (local_38 == 0xffffffff) {
local_c = 0xffffffff;
}
else {
*(int *)(param_1 + 0x4c) = (int)local_38;
*param_2 = *(long *)(lVar1 + 0x20);
if ((local_38 == 0) || (*(char *)*param_2 != -2)) {
if ((local_38 != 0) && (*(char *)*param_2 == '\x01')) {
*param_2 = *param_2 + 1;
local_38 = local_38 + -1;
}
*(int *)(param_1 + 0x40) = *(int *)(param_1 + 0x40) + 1;
local_c = (int4)local_38;
}
else {
local_c = 0xffffffff;
}
}
}
}
else {
*param_2 = *(long *)(param_1 + 0x30);
*(int8 *)(param_1 + 0x30) = 0;
*(int *)(param_1 + 0x40) = *(int *)(param_1 + 0x40) + 1;
local_c = *(int4 *)(param_1 + 0x38);
}
return local_c;
}
| |
51,260 | delete_dynamic_element | eloqsql/mysys/array.c | void delete_dynamic_element(DYNAMIC_ARRAY *array, uint idx)
{
char *ptr= (char*) array->buffer+array->size_of_element*idx;
array->elements--;
memmove(ptr,ptr+array->size_of_element,
(array->elements-idx)*array->size_of_element);
} | O3 | c | delete_dynamic_element:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %edx
movl 0x14(%rdi), %ecx
movl %ecx, %eax
imull %esi, %eax
addq (%rdi), %rax
decl %edx
movl %edx, 0x8(%rdi)
subl %esi, %edx
imull %ecx, %edx
movq %rcx, %rsi
addq %rax, %rsi
movq %rax, %rdi
popq %rbp
jmp 0x2a130
| delete_dynamic_element:
push rbp
mov rbp, rsp
mov edx, [rdi+8]
mov ecx, [rdi+14h]
mov eax, ecx
imul eax, esi
add rax, [rdi]
dec edx
mov [rdi+8], edx
sub edx, esi
imul edx, ecx
mov rsi, rcx
add rsi, rax
mov rdi, rax
pop rbp
jmp _memmove
| long long delete_dynamic_element(long long a1, int a2)
{
long long v2; // rcx
long long v3; // rax
int v4; // edx
v2 = *(unsigned int *)(a1 + 20);
v3 = *(_QWORD *)a1 + (unsigned int)(a2 * *(_DWORD *)(a1 + 20));
v4 = *(_DWORD *)(a1 + 8) - 1;
*(_DWORD *)(a1 + 8) = v4;
return memmove(v3, v3 + v2, (unsigned int)(v2 * (v4 - a2)));
}
| delete_dynamic_element:
PUSH RBP
MOV RBP,RSP
MOV EDX,dword ptr [RDI + 0x8]
MOV ECX,dword ptr [RDI + 0x14]
MOV EAX,ECX
IMUL EAX,ESI
ADD RAX,qword ptr [RDI]
DEC EDX
MOV dword ptr [RDI + 0x8],EDX
SUB EDX,ESI
IMUL EDX,ECX
MOV RSI,RCX
ADD RSI,RAX
MOV RDI,RAX
POP RBP
JMP 0x0012a130
|
void delete_dynamic_element(long *param_1,int param_2)
{
uint uVar1;
void *__dest;
int iVar2;
uVar1 = *(uint *)((long)param_1 + 0x14);
__dest = (void *)((ulong)(uVar1 * param_2) + *param_1);
iVar2 = (int)param_1[1] + -1;
*(int *)(param_1 + 1) = iVar2;
memmove(__dest,(void *)((ulong)uVar1 + (long)__dest),(ulong)((iVar2 - param_2) * uVar1));
return;
}
| |
51,261 | seek_io_cache | eloqsql/mysys/mf_iocache.c | void seek_io_cache(IO_CACHE *cache, my_off_t needed_offset)
{
my_off_t cached_data_start= cache->pos_in_file;
my_off_t cached_data_end= cache->pos_in_file + (cache->read_end -
cache->buffer);
if (needed_offset >= cached_data_start &&
needed_offset < cached_data_end)
{
/*
The offset we're seeking to is in the buffer.
Move buffer's read position accordingly
*/
cache->read_pos= cache->buffer + (needed_offset - cached_data_start);
}
else
{
if (needed_offset > cache->end_of_file)
needed_offset= cache->end_of_file;
/*
The offset we're seeking to is not in the buffer.
- Set the buffer to be exhausted.
- Make the next read to a mysql_file_seek() call to the required
offset.
TODO(cvicentiu, spetrunia) properly implement aligned seeks for
efficiency.
*/
cache->seek_not_done= 1;
cache->pos_in_file= needed_offset;
/* When reading it must appear as if we've started from the offset
that we've seeked here. We must let _my_b_cache_read assume that
by implying "no reading starting from pos_in_file" has happened. */
cache->read_pos= cache->buffer;
cache->read_end= cache->buffer;
}
} | O3 | c | seek_io_cache:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
movq 0x20(%rdi), %rax
movq %rsi, %rcx
subq %rdx, %rcx
jb 0x53236
subq %rax, %rdx
addq 0x18(%rdi), %rdx
cmpq %rsi, %rdx
jbe 0x53236
addq %rcx, %rax
movq %rax, 0x10(%rdi)
jmp 0x53256
movq 0x8(%rdi), %rcx
cmpq %rsi, %rcx
cmovbq %rcx, %rsi
movl $0x1, 0xe0(%rdi)
movq %rsi, (%rdi)
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
popq %rbp
retq
| seek_io_cache:
push rbp
mov rbp, rsp
mov rdx, [rdi]
mov rax, [rdi+20h]
mov rcx, rsi
sub rcx, rdx
jb short loc_53236
sub rdx, rax
add rdx, [rdi+18h]
cmp rdx, rsi
jbe short loc_53236
add rax, rcx
mov [rdi+10h], rax
jmp short loc_53256
loc_53236:
mov rcx, [rdi+8]
cmp rcx, rsi
cmovb rsi, rcx
mov dword ptr [rdi+0E0h], 1
mov [rdi], rsi
mov [rdi+10h], rax
mov [rdi+18h], rax
loc_53256:
pop rbp
retn
| long long seek_io_cache(long long a1, unsigned long long a2)
{
long long result; // rax
result = *(_QWORD *)(a1 + 32);
if ( a2 < *(_QWORD *)a1 || *(_QWORD *)(a1 + 24) + *(_QWORD *)a1 - result <= a2 )
{
if ( *(_QWORD *)(a1 + 8) < a2 )
a2 = *(_QWORD *)(a1 + 8);
*(_DWORD *)(a1 + 224) = 1;
*(_QWORD *)a1 = a2;
*(_QWORD *)(a1 + 16) = result;
*(_QWORD *)(a1 + 24) = result;
}
else
{
result += a2 - *(_QWORD *)a1;
*(_QWORD *)(a1 + 16) = result;
}
return result;
}
| seek_io_cache:
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x20]
MOV RCX,RSI
SUB RCX,RDX
JC 0x00153236
SUB RDX,RAX
ADD RDX,qword ptr [RDI + 0x18]
CMP RDX,RSI
JBE 0x00153236
ADD RAX,RCX
MOV qword ptr [RDI + 0x10],RAX
JMP 0x00153256
LAB_00153236:
MOV RCX,qword ptr [RDI + 0x8]
CMP RCX,RSI
CMOVC RSI,RCX
MOV dword ptr [RDI + 0xe0],0x1
MOV qword ptr [RDI],RSI
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],RAX
LAB_00153256:
POP RBP
RET
|
void seek_io_cache(ulong *param_1,ulong param_2)
{
ulong uVar1;
ulong uVar2;
uVar1 = *param_1;
uVar2 = param_1[4];
if ((param_2 < uVar1) || ((uVar1 - uVar2) + param_1[3] <= param_2)) {
if (param_1[1] < param_2) {
param_2 = param_1[1];
}
*(int4 *)(param_1 + 0x1c) = 1;
*param_1 = param_2;
param_1[2] = uVar2;
param_1[3] = uVar2;
}
else {
param_1[2] = uVar2 + (param_2 - uVar1);
}
return;
}
| |
51,262 | flux::parser::Parser::bitShift() | kvthweatt[P]FluxLang/src/parser/parser.cpp | std::unique_ptr<Expr> Parser::bitShift() {
auto expr = term();
while (match({
lexer::TokenType::LESS_LESS,
lexer::TokenType::GREATER_GREATER
})) {
auto op = previous_;
auto right = term();
expr = std::make_unique<BinaryExpr>(
std::move(expr),
op,
std::move(right),
makeRange(op, previous_)
);
}
return expr;
} | O3 | cpp | flux::parser::Parser::bitShift():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x24076
leaq 0x68(%r14), %r13
leaq 0x70(%rsp), %r15
leaq 0x20(%rsp), %r12
movabsq $0x4700000046, %rax # imm = 0x4700000046
movq %rax, 0x20(%rsp)
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x14610
testb %al, %al
je 0x23fe7
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups 0x30(%r13), %xmm3
movaps %xmm3, 0x50(%rsp)
movaps %xmm2, 0x40(%rsp)
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq %r15, 0x60(%rsp)
movq 0xa8(%r14), %rsi
movq 0xb0(%r14), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x91b8
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x24076
movups 0x38(%rsp), %xmm0
movaps %xmm0, 0x80(%rsp)
movups 0x90(%r14), %xmm0
movaps %xmm0, 0x90(%rsp)
movl $0x98, %edi
callq 0x6270
movq %rax, %rbp
movq (%rbx), %rax
movq %rax, 0x18(%rsp)
xorl %ecx, %ecx
movq %rcx, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rbp, %rdi
leaq 0x18(%rsp), %rsi
movq %r12, %rdx
leaq 0x8(%rsp), %rcx
leaq 0x80(%rsp), %r8
callq 0x11e60
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x23f8d
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x23fa6
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %rdi
movq %rbp, (%rbx)
testq %rdi, %rdi
je 0x23fb7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23fc7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x23e9e
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x6280
jmp 0x23e9e
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2400f
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %rbp, %rdx
callq 0x695f
jmp 0x24026
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2403d
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x2403d
jmp 0x24056
movq %rax, %r14
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x24059
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x6280
jmp 0x24059
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x24067
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x6440
| _ZN4flux6parser6Parser8bitShiftEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov r14, rsi
mov rbx, rdi
call _ZN4flux6parser6Parser4termEv; flux::parser::Parser::term(void)
lea r13, [r14+68h]
lea r15, [rsp+0D8h+var_68]
lea r12, [rsp+0D8h+var_B8]
loc_23E9E:
mov rax, 4700000046h
mov qword ptr [rsp+0D8h+var_B8], rax
mov edx, 2
mov rdi, r14
mov rsi, r12
call _ZN4flux6parser6Parser5matchESt16initializer_listINS_5lexer9TokenTypeEE; flux::parser::Parser::match(std::initializer_list<flux::lexer::TokenType>)
test al, al
jz loc_23FE7
movups xmm0, xmmword ptr [r13+0]
movups xmm1, xmmword ptr [r13+10h]
movups xmm2, xmmword ptr [r13+20h]
movups xmm3, xmmword ptr [r13+30h]
movaps [rsp+0D8h+var_88], xmm3
movaps [rsp+0D8h+var_98], xmm2
movaps [rsp+0D8h+var_A8], xmm1
movaps [rsp+0D8h+var_B8], xmm0
mov [rsp+0D8h+var_78], r15
mov rsi, [r14+0A8h]
mov rdx, [r14+0B0h]
add rdx, rsi
lea rdi, [rsp+0D8h+var_78]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rdi, [rsp+0D8h+var_C8]; this
mov rsi, r14
call _ZN4flux6parser6Parser4termEv; flux::parser::Parser::term(void)
movups xmm0, [rsp+0D8h+var_A8+8]
movaps [rsp+0D8h+var_58], xmm0
movups xmm0, xmmword ptr [r14+90h]
movaps [rsp+0D8h+var_48], xmm0
mov edi, 98h; unsigned __int64
call __Znwm; operator new(ulong)
mov rbp, rax
mov rax, [rbx]
mov [rsp+0D8h+var_C0], rax
xor ecx, ecx
mov [rbx], rcx
mov rax, [rsp+0D8h+var_C8]
mov [rsp+0D8h+var_D0], rax
mov [rsp+0D8h+var_C8], rcx
mov rdi, rbp
lea rsi, [rsp+0D8h+var_C0]
mov rdx, r12
lea rcx, [rsp+0D8h+var_D0]
lea r8, [rsp+0D8h+var_58]
call _ZN4flux6parser10BinaryExprC2ESt10unique_ptrINS0_4ExprESt14default_deleteIS3_EERKNS_5lexer5TokenES6_RKNS_6common11SourceRangeE; flux::parser::BinaryExpr::BinaryExpr(std::unique_ptr<flux::parser::Expr>,flux::lexer::Token const&,std::unique_ptr<flux::parser::Expr>,flux::common::SourceRange const&)
mov rdi, [rsp+0D8h+var_D0]
test rdi, rdi
jz short loc_23F8D
mov rax, [rdi]
call qword ptr [rax+8]
loc_23F8D:
mov [rsp+0D8h+var_D0], 0
mov rdi, [rsp+0D8h+var_C0]
test rdi, rdi
jz short loc_23FA6
mov rax, [rdi]
call qword ptr [rax+8]
loc_23FA6:
mov rdi, [rbx]
mov [rbx], rbp
test rdi, rdi
jz short loc_23FB7
mov rax, [rdi]
call qword ptr [rax+8]
loc_23FB7:
mov rdi, [rsp+0D8h+var_C8]
test rdi, rdi
jz short loc_23FC7
mov rax, [rdi]
call qword ptr [rax+8]
loc_23FC7:
mov rdi, [rsp+0D8h+var_78]; void *
cmp rdi, r15
jz loc_23E9E
mov rsi, [rsp+0D8h+var_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_23E9E
loc_23FE7:
mov rax, rbx
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_2400F
mov rax, [rdi]
call qword ptr [rax+8]
loc_2400F:
lea rdi, [rsp+arg_0]
lea rsi, [rsp+arg_10]
mov rdx, rbp
call _ZN4flux6parser6Parser8bitShiftEv_cold_1; flux::parser::Parser::bitShift(void) [clone]
jmp short loc_24026
mov r14, rax
loc_24026:
mov rdi, [rsp+arg_8]
test rdi, rdi
jz short loc_2403D
mov rax, [rdi]
call qword ptr [rax+8]
jmp short loc_2403D
jmp short loc_24056
mov r14, rax
loc_2403D:
mov rdi, [rsp+arg_58]; void *
cmp rdi, r15
jz short loc_24059
mov rsi, [rsp+arg_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_24059
loc_24056:
mov r14, rax
loc_24059:
mov rdi, [rbx]
test rdi, rdi
jz short loc_24067
mov rax, [rdi]
call qword ptr [rax+8]
loc_24067:
mov qword ptr [rbx], 0
mov rdi, r14
call __Unwind_Resume
| flux::parser::Parser * flux::parser::Parser::bitShift(flux::parser::Parser *this, long long a2)
{
__int128 v3; // xmm0
__int128 v4; // xmm1
__int128 v5; // xmm2
long long v6; // rbp
long long v7; // rdi
long long v9; // [rsp+8h] [rbp-D0h] BYREF
long long v10; // [rsp+10h] [rbp-C8h] BYREF
long long v11; // [rsp+18h] [rbp-C0h] BYREF
__int128 v12; // [rsp+20h] [rbp-B8h] BYREF
__m256i v13; // [rsp+30h] [rbp-A8h]
__int128 v14; // [rsp+50h] [rbp-88h]
void *v15; // [rsp+60h] [rbp-78h] BYREF
_QWORD v16[2]; // [rsp+70h] [rbp-68h] BYREF
_OWORD v17[5]; // [rsp+80h] [rbp-58h] BYREF
flux::parser::Parser::term(this);
while ( 1 )
{
*(_QWORD *)&v12 = 0x4700000046LL;
if ( !(unsigned __int8)flux::parser::Parser::match(a2, (long long)&v12, 2LL) )
break;
v3 = *(_OWORD *)(a2 + 104);
v4 = *(_OWORD *)(a2 + 120);
v5 = *(_OWORD *)(a2 + 136);
v14 = *(_OWORD *)(a2 + 152);
*(_OWORD *)&v13.m256i_u64[2] = v5;
*(_OWORD *)v13.m256i_i8 = v4;
v12 = v3;
v15 = v16;
std::string::_M_construct<char *>(
(long long)&v15,
*(_BYTE **)(a2 + 168),
*(_QWORD *)(a2 + 168) + *(_QWORD *)(a2 + 176));
flux::parser::Parser::term((flux::parser::Parser *)&v10);
v17[0] = *(_OWORD *)&v13.m256i_u64[1];
v17[1] = *(_OWORD *)(a2 + 144);
v6 = operator new(0x98uLL);
v11 = *(_QWORD *)this;
*(_QWORD *)this = 0LL;
v9 = v10;
v10 = 0LL;
flux::parser::BinaryExpr::BinaryExpr(v6, &v11, &v12, &v9, v17);
if ( v9 )
(*(void ( **)(long long))(*(_QWORD *)v9 + 8LL))(v9);
v9 = 0LL;
if ( v11 )
(*(void ( **)(long long))(*(_QWORD *)v11 + 8LL))(v11);
v7 = *(_QWORD *)this;
*(_QWORD *)this = v6;
if ( v7 )
(*(void ( **)(long long))(*(_QWORD *)v7 + 8LL))(v7);
if ( v10 )
(*(void ( **)(long long))(*(_QWORD *)v10 + 8LL))(v10);
if ( v15 != v16 )
operator delete(v15, v16[0] + 1LL);
}
return this;
}
| bitShift:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV R14,RSI
MOV RBX,RDI
CALL 0x00124076
LEA R13,[R14 + 0x68]
LEA R15,[RSP + 0x70]
LEA R12,[RSP + 0x20]
LAB_00123e9e:
MOV RAX,0x4700000046
MOV qword ptr [RSP + 0x20],RAX
LAB_00123ead:
MOV EDX,0x2
MOV RDI,R14
MOV RSI,R12
CALL 0x00114610
TEST AL,AL
JZ 0x00123fe7
MOVUPS XMM0,xmmword ptr [R13]
MOVUPS XMM1,xmmword ptr [R13 + 0x10]
MOVUPS XMM2,xmmword ptr [R13 + 0x20]
MOVUPS XMM3,xmmword ptr [R13 + 0x30]
MOVAPS xmmword ptr [RSP + 0x50],XMM3
MOVAPS xmmword ptr [RSP + 0x40],XMM2
MOVAPS xmmword ptr [RSP + 0x30],XMM1
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x60],R15
MOV RSI,qword ptr [R14 + 0xa8]
MOV RDX,qword ptr [R14 + 0xb0]
ADD RDX,RSI
LAB_00123f03:
LEA RDI,[RSP + 0x60]
CALL 0x001091b8
LAB_00123f0d:
LEA RDI,[RSP + 0x10]
MOV RSI,R14
CALL 0x00124076
MOVUPS XMM0,xmmword ptr [RSP + 0x38]
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVUPS XMM0,xmmword ptr [R14 + 0x90]
MOVAPS xmmword ptr [RSP + 0x90],XMM0
LAB_00123f37:
MOV EDI,0x98
CALL 0x00106270
MOV RBP,RAX
MOV RAX,qword ptr [RBX]
MOV qword ptr [RSP + 0x18],RAX
XOR ECX,ECX
MOV qword ptr [RBX],RCX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RCX
LAB_00123f60:
MOV RDI,RBP
LEA RSI,[RSP + 0x18]
MOV RDX,R12
LEA RCX,[RSP + 0x8]
LEA R8,[RSP + 0x80]
CALL 0x00111e60
LAB_00123f7d:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00123f8d
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_00123f8d:
MOV qword ptr [RSP + 0x8],0x0
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x00123fa6
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_00123fa6:
MOV RDI,qword ptr [RBX]
MOV qword ptr [RBX],RBP
TEST RDI,RDI
JZ 0x00123fb7
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_00123fb7:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x00123fc7
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_00123fc7:
MOV RDI,qword ptr [RSP + 0x60]
CMP RDI,R15
JZ 0x00123e9e
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x00106280
JMP 0x00123e9e
LAB_00123fe7:
MOV RAX,RBX
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* flux::parser::Parser::bitShift() */
void flux::parser::Parser::bitShift(void)
{
long *plVar1;
char cVar2;
BinaryExpr *pBVar3;
long in_RSI;
long *in_RDI;
long *local_d0;
long *local_c8;
long *local_c0;
int8 local_b8;
int4 uStack_b0;
int4 uStack_ac;
int4 local_a8;
int4 uStack_a4;
int4 uStack_a0;
int4 uStack_9c;
int4 local_98;
int4 uStack_94;
int4 uStack_90;
int4 uStack_8c;
int4 local_88;
int4 uStack_84;
int4 uStack_80;
int4 uStack_7c;
long *local_78 [2];
long local_68 [2];
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
term();
while( true ) {
local_b8 = 0x4700000046;
/* try { // try from 00123ead to 00123ebc has its CatchHandler @ 00124056 */
cVar2 = match();
if (cVar2 == '\0') break;
local_b8 = *(int8 *)(in_RSI + 0x68);
uStack_b0 = *(int4 *)(in_RSI + 0x70);
uStack_ac = *(int4 *)(in_RSI + 0x74);
local_a8 = *(int4 *)(in_RSI + 0x78);
uStack_a4 = *(int4 *)(in_RSI + 0x7c);
uStack_a0 = *(int4 *)(in_RSI + 0x80);
uStack_9c = *(int4 *)(in_RSI + 0x84);
local_98 = *(int4 *)(in_RSI + 0x88);
uStack_94 = *(int4 *)(in_RSI + 0x8c);
uStack_90 = *(int4 *)(in_RSI + 0x90);
uStack_8c = *(int4 *)(in_RSI + 0x94);
local_88 = *(int4 *)(in_RSI + 0x98);
uStack_84 = *(int4 *)(in_RSI + 0x9c);
uStack_80 = *(int4 *)(in_RSI + 0xa0);
uStack_7c = *(int4 *)(in_RSI + 0xa4);
/* try { // try from 00123f03 to 00123f0c has its CatchHandler @ 00124038 */
local_78[0] = local_68;
std::__cxx11::string::_M_construct<char*>
(local_78,*(long *)(in_RSI + 0xa8),*(long *)(in_RSI + 0xb0) + *(long *)(in_RSI + 0xa8)
);
/* try { // try from 00123f0d to 00123f19 has its CatchHandler @ 0012403a */
term();
local_58 = CONCAT44(uStack_9c,uStack_a0);
uStack_50 = CONCAT44(uStack_94,local_98);
local_48 = *(int8 *)(in_RSI + 0x90);
uStack_40 = *(int8 *)(in_RSI + 0x98);
/* try { // try from 00123f37 to 00123f40 has its CatchHandler @ 00124023 */
pBVar3 = (BinaryExpr *)operator_new(0x98);
local_c0 = (long *)*in_RDI;
*in_RDI = 0;
local_d0 = local_c8;
local_c8 = (long *)0x0;
/* try { // try from 00123f60 to 00123f7c has its CatchHandler @ 00123ffc */
BinaryExpr::BinaryExpr(pBVar3,&local_c0,&local_b8,&local_d0,&local_58);
if (local_d0 != (long *)0x0) {
(**(code **)(*local_d0 + 8))();
}
local_d0 = (long *)0x0;
if (local_c0 != (long *)0x0) {
(**(code **)(*local_c0 + 8))();
}
plVar1 = (long *)*in_RDI;
*in_RDI = (long)pBVar3;
if (plVar1 != (long *)0x0) {
(**(code **)(*plVar1 + 8))();
}
if (local_c8 != (long *)0x0) {
(**(code **)(*local_c8 + 8))();
}
if (local_78[0] != local_68) {
operator_delete(local_78[0],local_68[0] + 1);
}
}
return;
}
| |
51,263 | my_copy_fix_mb | eloqsql/strings/ctype-mb.c | size_t
my_copy_fix_mb(CHARSET_INFO *cs,
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t well_formed_nchars;
size_t well_formed_length;
size_t fixed_length;
size_t min_length= MY_MIN(src_length, dst_length);
well_formed_nchars= my_ci_well_formed_char_length(cs, src, src + min_length,
nchars, status);
DBUG_ASSERT(well_formed_nchars <= nchars);
well_formed_length= status->m_source_end_pos - src;
if (well_formed_length)
memmove(dst, src, well_formed_length);
if (!status->m_well_formed_error_pos)
return well_formed_length;
fixed_length= my_append_fix_badly_formed_tail(cs,
dst + well_formed_length,
dst + dst_length,
src + well_formed_length,
src + src_length,
nchars - well_formed_nchars,
status);
return well_formed_length + fixed_length;
} | O3 | c | my_copy_fix_mb:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq 0x10(%rbp), %rbx
cmpq %rdx, %r8
movq %r8, -0x58(%rbp)
cmovbq %r8, %rdx
addq %rcx, %rdx
movq 0xb8(%rdi), %rax
movq %rdi, -0x40(%rbp)
movq %rcx, %rsi
movq %r9, -0x30(%rbp)
movq %r9, %rcx
movq %rbx, %r8
callq *0xc8(%rax)
movq %rax, %r14
movq (%rbx), %rbx
subq %r15, %rbx
je 0x3f7ad
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x24610
movq 0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3f89c
leaq (%rbx,%r13), %rax
movq %rbx, -0x50(%rbp)
addq %r15, %rbx
movq -0x30(%rbp), %rcx
cmpq %r14, %rcx
movq %rax, -0x48(%rbp)
je 0x3f882
addq %r12, %r13
movq %r13, -0x38(%rbp)
addq -0x58(%rbp), %r15
subq %rcx, %r14
movq %rax, %r13
movq %r15, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq 0xb8(%rdi), %rax
movq %rbx, %rsi
movq %r15, %rdx
callq *0xc0(%rax)
testl %eax, %eax
jle 0x3f828
movl %eax, %r15d
leaq (%r15,%r13), %r12
cmpq -0x38(%rbp), %r12
ja 0x3f887
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x24290
movq %r12, %r13
jmp 0x3f870
setne %al
cmpq %r15, %rbx
setae %cl
testb %al, %cl
jne 0x3f887
movq 0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3f844
movq %rbx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movq 0xb8(%rdi), %rax
movl $0x3f, %esi
movq %r13, %rdx
movq -0x38(%rbp), %rcx
callq *0x30(%rax)
testl %eax, %eax
jle 0x3f887
movl %eax, %eax
addq %rax, %r13
movl $0x1, %r15d
movq %r13, %r12
addq %r15, %rbx
incq %r14
movq -0x30(%rbp), %r15
jne 0x3f7ed
jmp 0x3f88a
movq %rax, %r12
jmp 0x3f88a
movq %r13, %r12
movq 0x10(%rbp), %rax
movq %rbx, (%rax)
movq -0x50(%rbp), %rbx
subq -0x48(%rbp), %rbx
addq %r12, %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_copy_fix_mb:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, rcx
mov r12, rdx
mov r13, rsi
mov rbx, [rbp+arg_0]
cmp r8, rdx
mov [rbp+var_58], r8
cmovb rdx, r8
add rdx, rcx
mov rax, [rdi+0B8h]
mov [rbp+var_40], rdi
mov rsi, rcx
mov [rbp+var_30], r9
mov rcx, r9
mov r8, rbx
call qword ptr [rax+0C8h]
mov r14, rax
mov rbx, [rbx]
sub rbx, r15
jz short loc_3F7AD
mov rdi, r13
mov rsi, r15
mov rdx, rbx
call _memmove
loc_3F7AD:
mov rax, [rbp+arg_0]
cmp qword ptr [rax+8], 0
jz loc_3F89C
lea rax, [rbx+r13]
mov [rbp+var_50], rbx
add rbx, r15
mov rcx, [rbp+var_30]
cmp rcx, r14
mov [rbp+var_48], rax
jz loc_3F882
add r13, r12
mov [rbp+var_38], r13
add r15, [rbp+var_58]
sub r14, rcx
mov r13, rax
mov [rbp+var_30], r15
loc_3F7ED:
mov rdi, [rbp+var_40]
mov rax, [rdi+0B8h]
mov rsi, rbx
mov rdx, r15
call qword ptr [rax+0C0h]
test eax, eax
jle short loc_3F828
mov r15d, eax
lea r12, [r15+r13]
cmp r12, [rbp+var_38]
ja short loc_3F887
mov rdi, r13
mov rsi, rbx
mov rdx, r15
call _memcpy
mov r13, r12
jmp short loc_3F870
loc_3F828:
setnz al
cmp rbx, r15
setnb cl
test cl, al
jnz short loc_3F887
mov rax, [rbp+arg_0]
cmp qword ptr [rax+8], 0
jnz short loc_3F844
mov [rax+8], rbx
loc_3F844:
mov rdi, [rbp+var_40]
mov rax, [rdi+0B8h]
mov esi, 3Fh ; '?'
mov rdx, r13
mov rcx, [rbp+var_38]
call qword ptr [rax+30h]
test eax, eax
jle short loc_3F887
mov eax, eax
add r13, rax
mov r15d, 1
mov r12, r13
loc_3F870:
add rbx, r15
inc r14
mov r15, [rbp+var_30]
jnz loc_3F7ED
jmp short loc_3F88A
loc_3F882:
mov r12, rax
jmp short loc_3F88A
loc_3F887:
mov r12, r13
loc_3F88A:
mov rax, [rbp+arg_0]
mov [rax], rbx
mov rbx, [rbp+var_50]
sub rbx, [rbp+var_48]
add rbx, r12
loc_3F89C:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long my_copy_fix_mb(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
long long a6,
unsigned long long *a7)
{
unsigned long long v8; // r12
long long v9; // r14
long long v10; // rbx
unsigned long long v11; // rax
unsigned long long v12; // rbx
unsigned long long v13; // r15
long long v14; // r14
long long v15; // r13
int v16; // eax
long long v17; // r15
unsigned long long v18; // r12
int v19; // eax
long long v22; // [rsp+10h] [rbp-50h]
unsigned long long v23; // [rsp+18h] [rbp-48h]
unsigned long long v24; // [rsp+28h] [rbp-38h]
unsigned long long v26; // [rsp+30h] [rbp-30h]
v8 = a3;
if ( a5 < a3 )
a3 = a5;
v9 = (*(long long ( **)(long long, long long, unsigned long long, long long, unsigned long long *))(*(_QWORD *)(a1 + 184)
+ 200LL))(
a1,
a4,
a4 + a3,
a6,
a7);
v10 = *a7 - a4;
if ( v10 )
memmove(a2, a4, v10);
if ( !a7[1] )
return v10;
v11 = v10 + a2;
v22 = v10;
v12 = a4 + v10;
v23 = v11;
if ( a6 == v9 )
{
v18 = v11;
goto LABEL_20;
}
v24 = v8 + a2;
v13 = a5 + a4;
v14 = v9 - a6;
v15 = v11;
v26 = v13;
while ( 1 )
{
v16 = (*(long long ( **)(long long, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v12,
v13);
if ( v16 <= 0 )
break;
v17 = (unsigned int)v16;
v18 = (unsigned int)v16 + v15;
if ( v18 > v24 )
goto LABEL_19;
memcpy(v15, v12);
v15 = v18;
LABEL_16:
v12 += v17;
++v14;
v13 = v26;
if ( !v14 )
goto LABEL_20;
}
if ( v16 == 0 || v12 < v13 )
{
if ( !a7[1] )
a7[1] = v12;
v19 = (*(long long ( **)(long long, long long, long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
63LL,
v15,
v24);
if ( v19 > 0 )
{
v15 += (unsigned int)v19;
v17 = 1LL;
v18 = v15;
goto LABEL_16;
}
}
LABEL_19:
v18 = v15;
LABEL_20:
*a7 = v12;
return v18 + v22 - v23;
}
| my_copy_fix_mb:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,RCX
MOV R12,RDX
MOV R13,RSI
MOV RBX,qword ptr [RBP + 0x10]
CMP R8,RDX
MOV qword ptr [RBP + -0x58],R8
CMOVC RDX,R8
ADD RDX,RCX
MOV RAX,qword ptr [RDI + 0xb8]
MOV qword ptr [RBP + -0x40],RDI
MOV RSI,RCX
MOV qword ptr [RBP + -0x30],R9
MOV RCX,R9
MOV R8,RBX
CALL qword ptr [RAX + 0xc8]
MOV R14,RAX
MOV RBX,qword ptr [RBX]
SUB RBX,R15
JZ 0x0013f7ad
MOV RDI,R13
MOV RSI,R15
MOV RDX,RBX
CALL 0x00124610
LAB_0013f7ad:
MOV RAX,qword ptr [RBP + 0x10]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x0013f89c
LEA RAX,[RBX + R13*0x1]
MOV qword ptr [RBP + -0x50],RBX
ADD RBX,R15
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,R14
MOV qword ptr [RBP + -0x48],RAX
JZ 0x0013f882
ADD R13,R12
MOV qword ptr [RBP + -0x38],R13
ADD R15,qword ptr [RBP + -0x58]
SUB R14,RCX
MOV R13,RAX
MOV qword ptr [RBP + -0x30],R15
LAB_0013f7ed:
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RDI + 0xb8]
MOV RSI,RBX
MOV RDX,R15
CALL qword ptr [RAX + 0xc0]
TEST EAX,EAX
JLE 0x0013f828
MOV R15D,EAX
LEA R12,[R15 + R13*0x1]
CMP R12,qword ptr [RBP + -0x38]
JA 0x0013f887
MOV RDI,R13
MOV RSI,RBX
MOV RDX,R15
CALL 0x00124290
MOV R13,R12
JMP 0x0013f870
LAB_0013f828:
SETNZ AL
CMP RBX,R15
SETNC CL
TEST CL,AL
JNZ 0x0013f887
MOV RAX,qword ptr [RBP + 0x10]
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x0013f844
MOV qword ptr [RAX + 0x8],RBX
LAB_0013f844:
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RDI + 0xb8]
MOV ESI,0x3f
MOV RDX,R13
MOV RCX,qword ptr [RBP + -0x38]
CALL qword ptr [RAX + 0x30]
TEST EAX,EAX
JLE 0x0013f887
MOV EAX,EAX
ADD R13,RAX
MOV R15D,0x1
MOV R12,R13
LAB_0013f870:
ADD RBX,R15
INC R14
MOV R15,qword ptr [RBP + -0x30]
JNZ 0x0013f7ed
JMP 0x0013f88a
LAB_0013f882:
MOV R12,RAX
JMP 0x0013f88a
LAB_0013f887:
MOV R12,R13
LAB_0013f88a:
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX],RBX
MOV RBX,qword ptr [RBP + -0x50]
SUB RBX,qword ptr [RBP + -0x48]
ADD RBX,R12
LAB_0013f89c:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
size_t my_copy_fix_mb(long param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
long param_6,long *param_7)
{
void *pvVar1;
uint uVar2;
long lVar3;
size_t __n;
void *__src;
void *__dest;
ulong uVar4;
uVar4 = param_3;
if (param_5 < param_3) {
uVar4 = param_5;
}
lVar3 = (**(code **)(*(long *)(param_1 + 0xb8) + 200))
(param_1,param_4,uVar4 + (long)param_4,param_6,param_7);
__n = *param_7 - (long)param_4;
if (__n != 0) {
memmove(param_2,param_4,__n);
}
if (param_7[1] != 0) {
pvVar1 = (void *)(__n + (long)param_2);
__src = (void *)(__n + (long)param_4);
__dest = pvVar1;
if (param_6 != lVar3) {
lVar3 = lVar3 - param_6;
do {
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,__src,(void *)((long)param_4 + param_5));
if ((int)uVar2 < 1) {
if ((void *)((long)param_4 + param_5) <= __src && uVar2 != 0) break;
if (param_7[1] == 0) {
param_7[1] = (long)__src;
}
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))
(param_1,0x3f,__dest,(void *)((long)param_2 + param_3));
if ((int)uVar2 < 1) break;
__dest = (void *)((long)__dest + (ulong)uVar2);
uVar4 = 1;
}
else {
uVar4 = (ulong)uVar2;
if ((void *)((long)param_2 + param_3) < (void *)(uVar4 + (long)__dest)) break;
memcpy(__dest,__src,uVar4);
__dest = (void *)(uVar4 + (long)__dest);
}
__src = (void *)((long)__src + uVar4);
lVar3 = lVar3 + 1;
} while (lVar3 != 0);
}
*param_7 = (long)__src;
__n = (__n - (long)pvVar1) + (long)__dest;
}
return __n;
}
| |
51,264 | get_charset_number_internal | eloqsql/mysys/charset.c | static uint
get_charset_number_internal(const char *charset_name, uint cs_flags)
{
CHARSET_INFO **cs;
for (cs= all_charsets;
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if ( cs[0] && cs[0]->cs_name.str && (cs[0]->state & cs_flags) &&
!my_strcasecmp(&my_charset_latin1, cs[0]->cs_name.str, charset_name))
return cs[0]->number;
}
return 0;
} | O0 | c | get_charset_number_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0xba898a(%rip), %rax # 0xc89730
movq %rax, -0x20(%rbp)
leaq 0xba897f(%rip), %rax # 0xc89730
addq $0x4000, %rax # imm = 0x4000
cmpq %rax, -0x20(%rbp)
jae 0xe0e37
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe0e24
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xe0e24
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0xe0e24
leaq 0x293022(%rip), %rax # 0x373e10
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rsi
movq -0x10(%rbp), %rdx
leaq 0x293001(%rip), %rdi # 0x373e10
callq *%rax
cmpl $0x0, %eax
jne 0xe0e24
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xe0e3e
jmp 0xe0e26
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0xe0daa
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| get_charset_number_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
lea rax, all_charsets
mov [rbp+var_20], rax
loc_E0DAA:
lea rax, all_charsets
add rax, 4000h
cmp [rbp+var_20], rax
jnb short loc_E0E37
mov rax, [rbp+var_20]
cmp qword ptr [rax], 0
jz short loc_E0E24
mov rax, [rbp+var_20]
mov rax, [rax]
cmp qword ptr [rax+10h], 0
jz short loc_E0E24
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+0Ch]
and eax, [rbp+var_14]
cmp eax, 0
jz short loc_E0E24
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rcx, [rbp+var_20]
mov rcx, [rcx]
mov rsi, [rcx+10h]
mov rdx, [rbp+var_10]
lea rdi, my_charset_latin1
call rax
cmp eax, 0
jnz short loc_E0E24
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_4], eax
jmp short loc_E0E3E
loc_E0E24:
jmp short $+2
loc_E0E26:
mov rax, [rbp+var_20]
add rax, 8
mov [rbp+var_20], rax
jmp loc_E0DAA
loc_E0E37:
mov [rbp+var_4], 0
loc_E0E3E:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long get_charset_number_internal(long long a1, int a2)
{
unsigned int **i; // [rsp+0h] [rbp-20h]
for ( i = (unsigned int **)all_charsets; i < &all_charsets[2048]; ++i )
{
if ( *i
&& *((_QWORD *)*i + 2)
&& (a2 & (*i)[3]) != 0
&& !(*(unsigned int ( **)(void *, _QWORD, long long))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*((_QWORD *)*i + 2),
a1) )
{
return **i;
}
}
return 0;
}
| get_charset_number_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
LEA RAX,[0xd89730]
MOV qword ptr [RBP + -0x20],RAX
LAB_001e0daa:
LEA RAX,[0xd89730]
ADD RAX,0x4000
CMP qword ptr [RBP + -0x20],RAX
JNC 0x001e0e37
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x0
JZ 0x001e0e24
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x001e0e24
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,dword ptr [RBP + -0x14]
CMP EAX,0x0
JZ 0x001e0e24
LEA RAX,[0x473e10]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX]
MOV RSI,qword ptr [RCX + 0x10]
MOV RDX,qword ptr [RBP + -0x10]
LEA RDI,[0x473e10]
CALL RAX
CMP EAX,0x0
JNZ 0x001e0e24
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e0e3e
LAB_001e0e24:
JMP 0x001e0e26
LAB_001e0e26:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x8
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001e0daa
LAB_001e0e37:
MOV dword ptr [RBP + -0x4],0x0
LAB_001e0e3e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 get_charset_number_internal(int8 param_1,uint param_2)
{
int iVar1;
long *local_28;
local_28 = &all_charsets;
while( true ) {
if ((long *)0xd8d72f < local_28) {
return 0;
}
if ((((*local_28 != 0) && (*(long *)(*local_28 + 0x10) != 0)) &&
((*(uint *)(*local_28 + 0xc) & param_2) != 0)) &&
(iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_00473ed0 + 0x40))
(&my_charset_latin1,*(int8 *)(*local_28 + 0x10),param_1), iVar1 == 0
)) break;
local_28 = local_28 + 1;
}
return *(int4 *)*local_28;
}
| |
51,265 | stbi_zlib_decode_buffer | monkey531[P]llama/examples/llava/../../common/stb_image.h | STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
{
stbi__zbuf a;
a.zbuffer = (stbi_uc *) ibuffer;
a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
return (int) (a.zout - a.zout_start);
else
return -1;
} | O1 | c | stbi_zlib_decode_buffer:
pushq %rbp
pushq %rbx
subq $0x1008, %rsp # imm = 0x1008
movl %esi, %eax
movq %rdi, %rsi
movq %rsp, %rbx
movq %rdx, (%rbx)
movslq %ecx, %rcx
addq %rdx, %rcx
movq %rcx, 0x8(%rbx)
xorl %ebp, %ebp
movq %rbx, %rdi
movl %eax, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x29cd6
movl 0x20(%rbx), %ecx
subl 0x28(%rbx), %ecx
cmpl $0x1, %eax
sbbl %ebp, %ebp
orl %ecx, %ebp
movl %ebp, %eax
addq $0x1008, %rsp # imm = 0x1008
popq %rbx
popq %rbp
retq
| stbi_zlib_decode_buffer:
push rbp
push rbx
sub rsp, 1008h
mov eax, esi
mov rsi, rdi
mov rbx, rsp
mov [rbx], rdx
movsxd rcx, ecx
add rcx, rdx
mov [rbx+8], rcx
xor ebp, ebp
mov rdi, rbx
mov edx, eax
xor ecx, ecx
mov r8d, 1
call _ZL13stbi__do_zlibP10stbi__zbufPciii; stbi__do_zlib(stbi__zbuf *,char *,int,int,int)
mov ecx, [rbx+20h]
sub ecx, [rbx+28h]
cmp eax, 1
sbb ebp, ebp
or ebp, ecx
mov eax, ebp
add rsp, 1008h
pop rbx
pop rbp
retn
| long long stbi_zlib_decode_buffer(unsigned __int8 *a1, int a2, unsigned __int8 *a3, int a4)
{
int v4; // eax
unsigned __int8 *v6[4]; // [rsp+0h] [rbp-1018h] BYREF
int v7; // [rsp+20h] [rbp-FF8h]
int v8; // [rsp+28h] [rbp-FF0h]
v6[0] = a3;
v6[1] = &a3[a4];
v4 = stbi__do_zlib(v6, a1, a2, 0, 1);
return (v7 - v8) | (unsigned int)-(v4 == 0);
}
| stbi_zlib_decode_buffer:
PUSH RBP
PUSH RBX
SUB RSP,0x1008
MOV EAX,ESI
MOV RSI,RDI
MOV RBX,RSP
MOV qword ptr [RBX],RDX
MOVSXD RCX,ECX
ADD RCX,RDX
MOV qword ptr [RBX + 0x8],RCX
XOR EBP,EBP
MOV RDI,RBX
MOV EDX,EAX
XOR ECX,ECX
MOV R8D,0x1
CALL 0x00129cd6
MOV ECX,dword ptr [RBX + 0x20]
SUB ECX,dword ptr [RBX + 0x28]
CMP EAX,0x1
SBB EBP,EBP
OR EBP,ECX
MOV EAX,EBP
ADD RSP,0x1008
POP RBX
POP RBP
RET
|
uint stbi_zlib_decode_buffer(char *param_1,int param_2,long param_3,int param_4)
{
int iVar1;
long local_1018;
long local_1010;
int local_ff8;
int local_ff0;
local_1010 = param_4 + param_3;
local_1018 = param_3;
iVar1 = stbi__do_zlib((stbi__zbuf *)&local_1018,param_1,param_2,0,1);
return -(uint)(iVar1 == 0) | local_ff8 - local_ff0;
}
| |
51,266 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | monkey531[P]llama/common/json.hpp | bool key(string_t& val)
{
BasicJsonType k = BasicJsonType(val);
// check callback for key
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
}
return true;
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x60218
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x4, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x5d680
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
movl %eax, %ebp
leaq 0x48(%rbx), %rdi
movzbl %al, %esi
callq 0x5cdec
testb %bpl, %bpl
je 0x5d65e
movq 0x10(%rbx), %rax
cmpq $0x0, -0x8(%rax)
je 0x5d65e
leaq 0xa8(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x5e6fe
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x60252
leaq 0x20(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x5be0e
movq %rax, 0x70(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x59472
movq %r14, %rdi
callq 0x5ec5e
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x59472
movq %rbx, %rdi
callq 0x5ec5e
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1b320
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x59472
movq %r14, %rdi
callq 0x5ec5e
jmp 0x5d6a4
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x59472
movq %r14, %rdi
callq 0x5ec5e
movq %rbx, %rdi
callq 0x1bf90
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyERSB_:
push rbp
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+48h+var_3C], eax
mov [rsp+48h+var_3D], 4
cmp qword ptr [rbx+90h], 0
jz loc_5D680
lea rdi, [rbx+80h]
lea rsi, [rsp+48h+var_3C]
lea rdx, [rsp+48h+var_3D]
lea rcx, [rsp+48h+var_38]
call qword ptr [rbx+98h]
mov ebp, eax
lea rdi, [rbx+48h]
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
test bpl, bpl
jz short loc_5D65E
mov rax, [rbx+10h]
cmp qword ptr [rax-8], 0
jz short loc_5D65E
lea rsi, [rbx+0A8h]
lea rdi, [rsp+48h+var_28]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; 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>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rdi, [rax+8]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEixERSH_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator[](std::string const&)
lea r14, [rsp+48h+var_28]
mov rdi, rax
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov [rbx+70h], rax
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_5D65E:
lea rbx, [rsp+48h+var_38]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov al, 1
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_5D680:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov rbx, rax
lea r14, [rsp+48h+var_28]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_5D6A4
mov rbx, rax
loc_5D6A4:
lea r14, [rsp+48h+var_38]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
| char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::key(
long long a1,
long long a2)
{
unsigned __int8 v2; // bp
long long v3; // rax
char v5; // [rsp+Bh] [rbp-3Dh] BYREF
int v6; // [rsp+Ch] [rbp-3Ch] BYREF
char v7[16]; // [rsp+10h] [rbp-38h] BYREF
char v8[40]; // [rsp+20h] [rbp-28h] BYREF
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(v7);
v6 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v5 = 4;
if ( !*(_QWORD *)(a1 + 144) )
std::__throw_bad_function_call();
v2 = (*(long long ( **)(long long, int *, char *, char *))(a1 + 152))(a1 + 128, &v6, &v5, v7);
std::vector<bool>::push_back(a1 + 72, v2);
if ( v2 && *(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) )
{
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>::basic_json(
v8,
a1 + 168);
v3 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator[](
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) + 8LL),
a2);
*(_QWORD *)(a1 + 112) = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
v3,
(long long)v8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v8);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v7);
return 1;
}
| key:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RSP + 0x10]
CALL 0x00160218
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x4
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0015d680
LEA RDI,[RBX + 0x80]
LAB_0015d5e0:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
MOV EBP,EAX
LEA RDI,[RBX + 0x48]
MOVZX ESI,AL
CALL 0x0015cdec
TEST BPL,BPL
JZ 0x0015d65e
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RAX + -0x8],0x0
JZ 0x0015d65e
LEA RSI,[RBX + 0xa8]
LEA RDI,[RSP + 0x20]
CALL 0x0015e6fe
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
LAB_0015d630:
MOV RSI,R14
CALL 0x00160252
LEA R14,[RSP + 0x20]
MOV RDI,RAX
MOV RSI,R14
CALL 0x0015be0e
MOV qword ptr [RBX + 0x70],RAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x00159472
MOV RDI,R14
CALL 0x0015ec5e
LAB_0015d65e:
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00159472
MOV RDI,RBX
CALL 0x0015ec5e
MOV AL,0x1
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0015d680:
CALL 0x0011b320
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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> >::key(std::__cxx11::string&) */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<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>>
::key(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,string *param_1)
{
bool 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>
*pbVar2;
int8 uVar3;
int1 local_3d;
int4 local_3c;
data local_38 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_28 [16];
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_38);
local_3c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_3d = 4;
if (*(long *)(this + 0x90) != 0) {
/* try { // try from 0015d5e0 to 0015d623 has its CatchHandler @ 0015d6a1 */
bVar1 = (bool)(**(code **)(this + 0x98))(this + 0x80,&local_3c,&local_3d,local_38);
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x48),bVar1);
if ((bVar1 != false) && (*(long *)(*(long *)(this + 0x10) + -8) != 0)) {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_28,(basic_json *)(this + 0xa8));
/* try { // try from 0015d630 to 0015d637 has its CatchHandler @ 0015d685 */
pbVar2 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::operator[](*(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(*(long *)(*(long *)(this + 0x10) + -8) + 8),param_1);
uVar3 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(pbVar2,(data *)local_28);
*(int8 *)(this + 0x70) = uVar3;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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((data *)local_28,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_28);
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_38,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_38);
return 1;
}
/* WARNING: Subroutine does not return */
/* try { // try from 0015d680 to 0015d684 has its CatchHandler @ 0015d6a1 */
std::__throw_bad_function_call();
}
| |
51,267 | spdlog::details::I_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v8::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | aimrt_mujoco_sim/_deps/spdlog_lib-src/include/spdlog/pattern_formatter-inl.h | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(to12h(tm_time), dest);
} | O3 | c | spdlog::details::I_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v8::basic_memory_buffer<char, 250ul, std::allocator<char>>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movl 0x8(%rdx), %ecx
leal -0xc(%rcx), %eax
cmpl $0xd, %ecx
cmovll %ecx, %eax
cmpl $0x63, %eax
ja 0x428ca
movzbl %al, %ebp
imull $0xcd, %ebp, %r14d
shrl $0xb, %r14d
leal (%r14,%r14), %eax
leal (%rax,%rax,4), %eax
subb %al, %bpl
orb $0x30, %r14b
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x4288e
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb %r14b, (%rcx,%rax)
orb $0x30, %bpl
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x428bc
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb %bpl, (%rcx,%rax)
jmp 0x4290a
movl %eax, %eax
movq %rsp, %r8
movq %rax, (%r8)
movq 0x10(%rbx), %rax
leaq 0x18(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x19dae(%rip), %rax # 0x5c698
movq %rax, (%rdi)
movq %rbx, 0x20(%rdi)
leaq 0x8a77(%rip), %rsi # 0x4b36f
movl $0x5, %edx
movl $0x1, %ecx
xorl %r9d, %r9d
callq 0x2b306
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| _ZN6spdlog7details11I_formatterINS0_18null_scoped_padderEE6formatERKNS0_7log_msgERK2tmRN3fmt2v819basic_memory_bufferIcLm250ESaIcEEE:
push rbp
push r14
push rbx
sub rsp, 40h
mov rbx, rcx
mov ecx, [rdx+8]
lea eax, [rcx-0Ch]
cmp ecx, 0Dh
cmovl eax, ecx
cmp eax, 63h ; 'c'
ja short loc_428CA
movzx ebp, al
imul r14d, ebp, 0CDh
shr r14d, 0Bh
lea eax, [r14+r14]
lea eax, [rax+rax*4]
sub bpl, al
or r14b, 30h
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_4288E
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_4288E:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov [rcx+rax], r14b
or bpl, 30h
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_428BC
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_428BC:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov [rcx+rax], bpl
jmp short loc_4290A
loc_428CA:
mov eax, eax
mov r8, rsp
mov [r8], rax
mov rax, [rbx+10h]
lea rdi, [rsp+58h+var_40]
mov [rdi+10h], rax
mov [rdi+18h], rax
lea rax, off_5C698
mov [rdi], rax
mov [rdi+20h], rbx
lea rsi, a02; "{:02}"
mov edx, 5
mov ecx, 1
xor r9d, r9d
call _ZN3fmt2v86detail10vformat_toIcEEvRNS1_6bufferIT_EENS0_17basic_string_viewIS4_EENS0_17basic_format_argsINS0_20basic_format_contextINSt11conditionalIXsr3std7is_sameINS0_13type_identityIS4_E4typeEcEE5valueENS0_8appenderESt20back_insert_iteratorINS3_ISE_EEEE4typeESE_EEEENS1_10locale_refE
loc_4290A:
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
| char * spdlog::details::I_formatter<spdlog::details::null_scoped_padder>::format(
long long a1,
long long a2,
long long a3,
long long a4)
{
int v5; // ecx
unsigned int v6; // eax
char v7; // bp
char v8; // r14
long long v9; // rax
long long v10; // rsi
long long v11; // rcx
char v12; // bp
char *result; // rax
char *v14; // rsi
long long v15; // rcx
_QWORD v16[3]; // [rsp+0h] [rbp-58h] BYREF
long long ( **v17)(); // [rsp+18h] [rbp-40h] BYREF
long long v18; // [rsp+28h] [rbp-30h]
long long v19; // [rsp+30h] [rbp-28h]
long long v20; // [rsp+38h] [rbp-20h]
v5 = *(_DWORD *)(a3 + 8);
v6 = v5 - 12;
if ( v5 < 13 )
v6 = *(_DWORD *)(a3 + 8);
if ( v6 > 0x63 )
{
v16[0] = v6;
v18 = *(_QWORD *)(a4 + 16);
v19 = v18;
v17 = &off_5C698;
v20 = a4;
return fmt::v8::detail::vformat_to<char>((long long)&v17, "{:02}", 5LL, 1LL, (long long)v16, 0LL);
}
else
{
v7 = (unsigned __int8)v6 % 0xAu;
v8 = ((unsigned __int8)v6 / 0xAu) | 0x30;
v9 = *(_QWORD *)(a4 + 16);
v10 = v9 + 1;
if ( *(_QWORD *)(a4 + 24) < (unsigned long long)(v9 + 1) )
{
(**(void ( ***)(long long))a4)(a4);
v9 = *(_QWORD *)(a4 + 16);
v10 = v9 + 1;
}
v11 = *(_QWORD *)(a4 + 8);
*(_QWORD *)(a4 + 16) = v10;
*(_BYTE *)(v11 + v9) = v8;
v12 = v7 | 0x30;
result = *(char **)(a4 + 16);
v14 = result + 1;
if ( *(_QWORD *)(a4 + 24) < (unsigned long long)(result + 1) )
{
(**(void ( ***)(long long))a4)(a4);
result = *(char **)(a4 + 16);
v14 = result + 1;
}
v15 = *(_QWORD *)(a4 + 8);
*(_QWORD *)(a4 + 16) = v14;
result[v15] = v12;
}
return result;
}
| format:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RCX
MOV ECX,dword ptr [RDX + 0x8]
LEA EAX,[RCX + -0xc]
CMP ECX,0xd
CMOVL EAX,ECX
CMP EAX,0x63
JA 0x001428ca
MOVZX EBP,AL
IMUL R14D,EBP,0xcd
SHR R14D,0xb
LEA EAX,[R14 + R14*0x1]
LEA EAX,[RAX + RAX*0x4]
SUB BPL,AL
OR R14B,0x30
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x0014288e
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_0014288e:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],R14B
OR BPL,0x30
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x001428bc
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_001428bc:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],BPL
JMP 0x0014290a
LAB_001428ca:
MOV EAX,EAX
MOV R8,RSP
MOV qword ptr [R8],RAX
MOV RAX,qword ptr [RBX + 0x10]
LEA RDI,[RSP + 0x18]
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x15c698]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x20],RBX
LEA RSI,[0x14b36f]
MOV EDX,0x5
MOV ECX,0x1
XOR R9D,R9D
CALL 0x0012b306
LAB_0014290a:
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
|
/* spdlog::details::I_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg
const&, tm const&, fmt::v8::basic_memory_buffer<char, 250ul, std::allocator<char> >&) */
void __thiscall
spdlog::details::I_formatter<spdlog::details::null_scoped_padder>::format
(I_formatter<spdlog::details::null_scoped_padder> *this,log_msg *param_1,tm *param_2,
basic_memory_buffer *param_3)
{
uint uVar1;
byte bVar2;
uint uVar3;
long lVar4;
ulong uVar5;
ulong local_58 [3];
int **local_40 [2];
int8 local_30;
int8 local_28;
basic_memory_buffer *local_20;
uVar1 = param_2->tm_hour;
uVar3 = uVar1 - 0xc;
if ((int)uVar1 < 0xd) {
uVar3 = uVar1;
}
if (uVar3 < 100) {
bVar2 = (byte)((uVar3 & 0xff) / 10);
lVar4 = *(long *)(param_3 + 0x10);
uVar5 = lVar4 + 1;
if (*(ulong *)(param_3 + 0x18) < uVar5) {
(*(code *)**(int8 **)param_3)(param_3);
lVar4 = *(long *)(param_3 + 0x10);
uVar5 = lVar4 + 1;
}
*(ulong *)(param_3 + 0x10) = uVar5;
*(byte *)(*(long *)(param_3 + 8) + lVar4) = bVar2 | 0x30;
lVar4 = *(long *)(param_3 + 0x10);
uVar5 = lVar4 + 1;
if (*(ulong *)(param_3 + 0x18) < uVar5) {
(*(code *)**(int8 **)param_3)(param_3);
lVar4 = *(long *)(param_3 + 0x10);
uVar5 = lVar4 + 1;
}
*(ulong *)(param_3 + 0x10) = uVar5;
*(byte *)(*(long *)(param_3 + 8) + lVar4) = (char)uVar3 + bVar2 * -10 | 0x30;
}
else {
local_58[0] = (ulong)uVar3;
local_30 = *(int8 *)(param_3 + 0x10);
local_40[0] = &PTR_grow_0015c698;
local_28 = local_30;
local_20 = param_3;
fmt::v8::detail::vformat_to<char>(local_40,"{:02}",5,1,local_58,0);
}
return;
}
| |
51,268 | retrieve_auto_increment | eloqsql/storage/myisam/mi_key.c | ulonglong retrieve_auto_increment(MI_INFO *info,const uchar *record)
{
ulonglong value= 0; /* Store unsigned values here */
longlong s_value= 0; /* Store signed values here */
HA_KEYSEG *keyseg= info->s->keyinfo[info->s->base.auto_key-1].seg;
const uchar *key= (uchar*) record + keyseg->start;
switch (keyseg->type) {
case HA_KEYTYPE_INT8:
s_value= (longlong) *(const signed char*) key;
break;
case HA_KEYTYPE_BINARY:
value=(ulonglong) *(uchar*) key;
break;
case HA_KEYTYPE_SHORT_INT:
s_value= (longlong) sint2korr(key);
break;
case HA_KEYTYPE_USHORT_INT:
value=(ulonglong) uint2korr(key);
break;
case HA_KEYTYPE_LONG_INT:
s_value= (longlong) sint4korr(key);
break;
case HA_KEYTYPE_ULONG_INT:
value=(ulonglong) uint4korr(key);
break;
case HA_KEYTYPE_INT24:
s_value= (longlong) sint3korr(key);
break;
case HA_KEYTYPE_UINT24:
value=(ulonglong) uint3korr(key);
break;
case HA_KEYTYPE_FLOAT: /* This shouldn't be used */
{
float f_1;
float4get(f_1,key);
/* Ignore negative values */
value = (f_1 < (float) 0.0) ? 0 : (ulonglong) f_1;
break;
}
case HA_KEYTYPE_DOUBLE: /* This shouldn't be used */
{
double f_1;
float8get(f_1,key);
/* Ignore negative values */
value = (f_1 < 0.0) ? 0 : (ulonglong) f_1;
break;
}
case HA_KEYTYPE_LONGLONG:
s_value= sint8korr(key);
break;
case HA_KEYTYPE_ULONGLONG:
value= uint8korr(key);
break;
default:
DBUG_ASSERT(0);
value=0; /* Error */
break;
}
/*
The following code works because if s_value < 0 then value is 0
and if s_value == 0 then value will contain either s_value or the
correct value.
*/
return (s_value > 0) ? (ulonglong) s_value : value;
} | O3 | c | retrieve_auto_increment:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x218(%rax), %rcx
movl 0x184(%rax), %eax
decl %eax
imulq $0x70, %rax, %rax
movq 0x28(%rcx,%rax), %rcx
movzbl 0x18(%rcx), %edx
xorl %eax, %eax
addl $-0x2, %edx
cmpl $0xc, %edx
ja 0x7d08a
movl 0x8(%rcx), %ecx
leaq 0x66038(%rip), %rdi # 0xe2fc4
movslq (%rdi,%rdx,4), %rdx
addq %rdi, %rdx
jmpq *%rdx
movzbl (%rsi,%rcx), %eax
jmp 0x7d08a
movzwl (%rsi,%rcx), %edx
movzbl 0x2(%rsi,%rcx), %eax
shll $0x10, %eax
orq %rdx, %rax
jmp 0x7d08a
movslq (%rsi,%rcx), %rcx
jmp 0x7d081
movzwl (%rsi,%rcx), %eax
jmp 0x7d08a
movsbq (%rsi,%rcx), %rcx
jmp 0x7d081
movswq (%rsi,%rcx), %rcx
jmp 0x7d081
movl (%rsi,%rcx), %eax
jmp 0x7d08a
movq (%rsi,%rcx), %rcx
jmp 0x7d081
movss (%rsi,%rcx), %xmm0
xorps %xmm1, %xmm1
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andnps %xmm0, %xmm2
cvttss2si %xmm2, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subss 0x5cff4(%rip), %xmm2 # 0xda004
cvttss2si %xmm2, %rax
jmp 0x7d046
movsd (%rsi,%rcx), %xmm0
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmplesd %xmm1, %xmm2
andnpd %xmm0, %xmm2
cvttsd2si %xmm2, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x65627(%rip), %xmm2 # 0xe2668
cvttsd2si %xmm2, %rax
andq %rdx, %rax
orq %rcx, %rax
jmp 0x7d08a
movzbl 0x2(%rsi,%rcx), %edi
movl %edi, %eax
shll $0x10, %eax
movzbl 0x1(%rsi,%rcx), %edx
shll $0x8, %edx
movzbl (%rsi,%rcx), %ecx
testb %dil, %dil
js 0x7d075
orl %ecx, %eax
orl %edx, %eax
jmp 0x7d07e
movq (%rsi,%rcx), %rax
jmp 0x7d08a
orl %ecx, %edx
addl %edx, %eax
addl $0xff000000, %eax # imm = 0xFF000000
movslq %eax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
cmovgq %rcx, %rax
popq %rbp
retq
| retrieve_auto_increment:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov rcx, [rax+218h]
mov eax, [rax+184h]
dec eax
imul rax, 70h ; 'p'
mov rcx, [rcx+rax+28h]
movzx edx, byte ptr [rcx+18h]
xor eax, eax
add edx, 0FFFFFFFEh; switch 13 cases
cmp edx, 0Ch
ja def_7CF93; jumptable 000000000007CF93 default case, case 7
mov ecx, [rcx+8]
lea rdi, jpt_7CF93
movsxd rdx, ds:(jpt_7CF93 - 0E2FC4h)[rdi+rdx*4]
add rdx, rdi
jmp rdx; switch jump
loc_7CF95:
movzx eax, byte ptr [rsi+rcx]; jumptable 000000000007CF93 case 2
jmp def_7CF93; jumptable 000000000007CF93 default case, case 7
loc_7CF9E:
movzx edx, word ptr [rsi+rcx]; jumptable 000000000007CF93 case 13
movzx eax, byte ptr [rsi+rcx+2]
shl eax, 10h
or rax, rdx
jmp def_7CF93; jumptable 000000000007CF93 default case, case 7
loc_7CFB2:
movsxd rcx, dword ptr [rsi+rcx]; jumptable 000000000007CF93 case 4
jmp loc_7D081
loc_7CFBB:
movzx eax, word ptr [rsi+rcx]; jumptable 000000000007CF93 case 8
jmp def_7CF93; jumptable 000000000007CF93 default case, case 7
loc_7CFC4:
movsx rcx, byte ptr [rsi+rcx]; jumptable 000000000007CF93 case 14
jmp loc_7D081
loc_7CFCE:
movsx rcx, word ptr [rsi+rcx]; jumptable 000000000007CF93 case 3
jmp loc_7D081
loc_7CFD8:
mov eax, [rsi+rcx]; jumptable 000000000007CF93 case 9
jmp def_7CF93; jumptable 000000000007CF93 default case, case 7
loc_7CFE0:
mov rcx, [rsi+rcx]; jumptable 000000000007CF93 case 10
jmp loc_7D081
loc_7CFE9:
movss xmm0, dword ptr [rsi+rcx]; jumptable 000000000007CF93 case 5
xorps xmm1, xmm1
movaps xmm2, xmm0
cmpless xmm2, xmm1
andnps xmm2, xmm0
cvttss2si rcx, xmm2
mov rdx, rcx
sar rdx, 3Fh
subss xmm2, cs:dword_DA004
cvttss2si rax, xmm2
jmp short loc_7D046
loc_7D017:
movsd xmm0, qword ptr [rsi+rcx]; jumptable 000000000007CF93 case 6
xorpd xmm1, xmm1
movapd xmm2, xmm0
cmplesd xmm2, xmm1
andnpd xmm2, xmm0
cvttsd2si rcx, xmm2
mov rdx, rcx
sar rdx, 3Fh
subsd xmm2, cs:qword_E2668
cvttsd2si rax, xmm2
loc_7D046:
and rax, rdx
or rax, rcx
jmp short def_7CF93; jumptable 000000000007CF93 default case, case 7
loc_7D04E:
movzx edi, byte ptr [rsi+rcx+2]; jumptable 000000000007CF93 case 12
mov eax, edi
shl eax, 10h
movzx edx, byte ptr [rsi+rcx+1]
shl edx, 8
movzx ecx, byte ptr [rsi+rcx]
test dil, dil
js short loc_7D075
or eax, ecx
or eax, edx
jmp short loc_7D07E
loc_7D06F:
mov rax, [rsi+rcx]; jumptable 000000000007CF93 case 11
jmp short def_7CF93; jumptable 000000000007CF93 default case, case 7
loc_7D075:
or edx, ecx
add eax, edx
add eax, 0FF000000h
loc_7D07E:
movsxd rcx, eax
loc_7D081:
xor eax, eax
test rcx, rcx
cmovg rax, rcx
def_7CF93:
pop rbp; jumptable 000000000007CF93 default case, case 7
retn
| unsigned long long retrieve_auto_increment(long long a1, long long a2)
{
long long v2; // rcx
int v3; // edx
unsigned long long result; // rax
long long v5; // rcx
long long v6; // rcx
char v8; // di
int v9; // eax
int v10; // edx
int v11; // ecx
int v12; // eax
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 536LL)
+ 112LL * (unsigned int)(*(_DWORD *)(*(_QWORD *)a1 + 388LL) - 1)
+ 40);
v3 = *(unsigned __int8 *)(v2 + 24);
result = 0LL;
v5 = *(unsigned int *)(v2 + 8);
switch ( v3 )
{
case 2:
return *(unsigned __int8 *)(a2 + v5);
case 3:
v6 = *(__int16 *)(a2 + v5);
goto LABEL_18;
case 4:
v6 = *(int *)(a2 + v5);
goto LABEL_18;
case 5:
return (unsigned int)(int)_mm_andnot_ps(
_mm_cmple_ss((__m128)*(unsigned int *)(a2 + v5), (__m128)0LL),
(__m128)*(unsigned int *)(a2 + v5)).m128_f32[0];
case 6:
return (unsigned int)(int)COERCE_DOUBLE(~(unsigned long long)*(_OWORD *)&_mm_cmple_sd(
(__m128d)*(unsigned long long *)(a2 + v5),
(__m128d)0LL) & *(_QWORD *)(a2 + v5));
case 8:
return *(unsigned __int16 *)(a2 + v5);
case 9:
return *(unsigned int *)(a2 + v5);
case 10:
v6 = *(_QWORD *)(a2 + v5);
goto LABEL_18;
case 11:
return *(_QWORD *)(a2 + v5);
case 12:
v8 = *(_BYTE *)(a2 + v5 + 2);
v9 = (unsigned __int8)v8 << 16;
v10 = *(unsigned __int8 *)(a2 + v5 + 1) << 8;
v11 = *(unsigned __int8 *)(a2 + v5);
if ( v8 < 0 )
v12 = (v11 | v10) + v9 - 0x1000000;
else
v12 = v10 | v11 | v9;
v6 = v12;
goto LABEL_18;
case 13:
return *(unsigned __int16 *)(a2 + v5) | (unsigned long long)(*(unsigned __int8 *)(a2 + v5 + 2) << 16);
case 14:
v6 = *(char *)(a2 + v5);
LABEL_18:
result = 0LL;
if ( v6 > 0 )
result = v6;
break;
default:
return result;
}
return result;
}
| retrieve_auto_increment:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RAX + 0x218]
MOV EAX,dword ptr [RAX + 0x184]
DEC EAX
IMUL RAX,RAX,0x70
MOV RCX,qword ptr [RCX + RAX*0x1 + 0x28]
MOVZX EDX,byte ptr [RCX + 0x18]
XOR EAX,EAX
ADD EDX,-0x2
CMP EDX,0xc
JA 0x0017d08a
MOV ECX,dword ptr [RCX + 0x8]
LEA RDI,[0x1e2fc4]
MOVSXD RDX,dword ptr [RDI + RDX*0x4]
ADD RDX,RDI
switchD:
JMP RDX
caseD_2:
MOVZX EAX,byte ptr [RSI + RCX*0x1]
JMP 0x0017d08a
caseD_d:
MOVZX EDX,word ptr [RSI + RCX*0x1]
MOVZX EAX,byte ptr [RSI + RCX*0x1 + 0x2]
SHL EAX,0x10
OR RAX,RDX
JMP 0x0017d08a
caseD_4:
MOVSXD RCX,dword ptr [RSI + RCX*0x1]
JMP 0x0017d081
caseD_8:
MOVZX EAX,word ptr [RSI + RCX*0x1]
JMP 0x0017d08a
caseD_e:
MOVSX RCX,byte ptr [RSI + RCX*0x1]
JMP 0x0017d081
caseD_3:
MOVSX RCX,word ptr [RSI + RCX*0x1]
JMP 0x0017d081
caseD_9:
MOV EAX,dword ptr [RSI + RCX*0x1]
JMP 0x0017d08a
caseD_a:
MOV RCX,qword ptr [RSI + RCX*0x1]
JMP 0x0017d081
caseD_5:
MOVSS XMM0,dword ptr [RSI + RCX*0x1]
XORPS XMM1,XMM1
MOVAPS XMM2,XMM0
CMPLESS XMM2,XMM1
ANDNPS XMM2,XMM0
CVTTSS2SI RCX,XMM2
MOV RDX,RCX
SAR RDX,0x3f
SUBSS XMM2,dword ptr [0x001da004]
CVTTSS2SI RAX,XMM2
JMP 0x0017d046
caseD_6:
MOVSD XMM0,qword ptr [RSI + RCX*0x1]
XORPD XMM1,XMM1
MOVAPD XMM2,XMM0
CMPLESD XMM2,XMM1
ANDNPD XMM2,XMM0
CVTTSD2SI RCX,XMM2
MOV RDX,RCX
SAR RDX,0x3f
SUBSD XMM2,qword ptr [0x001e2668]
CVTTSD2SI RAX,XMM2
LAB_0017d046:
AND RAX,RDX
OR RAX,RCX
JMP 0x0017d08a
caseD_c:
MOVZX EDI,byte ptr [RSI + RCX*0x1 + 0x2]
MOV EAX,EDI
SHL EAX,0x10
MOVZX EDX,byte ptr [RSI + RCX*0x1 + 0x1]
SHL EDX,0x8
MOVZX ECX,byte ptr [RSI + RCX*0x1]
TEST DIL,DIL
JS 0x0017d075
OR EAX,ECX
OR EAX,EDX
JMP 0x0017d07e
caseD_b:
MOV RAX,qword ptr [RSI + RCX*0x1]
JMP 0x0017d08a
LAB_0017d075:
OR EDX,ECX
ADD EAX,EDX
ADD EAX,0xff000000
LAB_0017d07e:
MOVSXD RCX,EAX
LAB_0017d081:
XOR EAX,EAX
TEST RCX,RCX
CMOVG RAX,RCX
caseD_7:
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong retrieve_auto_increment(long *param_1,long param_2)
{
byte bVar1;
byte bVar2;
long lVar3;
uint uVar4;
ulong uVar5;
ulong uVar6;
float fVar7;
double dVar8;
lVar3 = *(long *)(*(long *)(*param_1 + 0x218) + 0x28 +
(ulong)(*(int *)(*param_1 + 0x184) - 1) * 0x70);
uVar4 = (uint)*(byte *)(lVar3 + 0x18);
if (0xc < uVar4 - 2) {
return 0;
}
uVar6 = (ulong)*(uint *)(lVar3 + 8);
uVar5 = 0;
switch(uVar4) {
case 2:
uVar5 = (ulong)*(byte *)(param_2 + uVar6);
break;
case 3:
uVar6 = (ulong)*(short *)(param_2 + uVar6);
goto LAB_0017d081;
case 4:
uVar6 = (ulong)*(int *)(param_2 + uVar6);
goto LAB_0017d081;
case 5:
fVar7 = (float)(~-(uint)(*(float *)(param_2 + uVar6) <= 0.0) & (uint)*(float *)(param_2 + uVar6)
);
uVar5 = (ulong)fVar7;
uVar6 = (ulong)(fVar7 - _DAT_001da004);
goto LAB_0017d046;
case 6:
dVar8 = (double)(~-(ulong)(*(double *)(param_2 + uVar6) <= 0.0) &
(ulong)*(double *)(param_2 + uVar6));
uVar5 = (ulong)dVar8;
uVar6 = (ulong)(dVar8 - _DAT_001e2668);
LAB_0017d046:
uVar5 = uVar6 & (long)uVar5 >> 0x3f | uVar5;
break;
case 8:
uVar5 = (ulong)*(ushort *)(param_2 + uVar6);
break;
case 9:
uVar5 = (ulong)*(uint *)(param_2 + uVar6);
break;
case 10:
uVar6 = *(ulong *)(param_2 + uVar6);
goto LAB_0017d081;
case 0xb:
uVar5 = *(ulong *)(param_2 + uVar6);
break;
case 0xc:
bVar1 = *(byte *)(param_2 + 2 + uVar6);
uVar4 = (uint)bVar1 * 0x10000;
bVar2 = *(byte *)(param_2 + 1 + uVar6);
if ((char)bVar1 < '\0') {
uVar4 = (uVar4 + CONCAT11(bVar2,*(byte *)(param_2 + uVar6))) - 0x1000000;
}
else {
uVar4 = uVar4 | *(byte *)(param_2 + uVar6) | (uint)bVar2 << 8;
}
uVar6 = (ulong)(int)uVar4;
goto LAB_0017d081;
case 0xd:
uVar5 = (ulong)CONCAT12(*(int1 *)(param_2 + 2 + uVar6),*(int2 *)(param_2 + uVar6));
break;
case 0xe:
uVar6 = (ulong)*(char *)(param_2 + uVar6);
LAB_0017d081:
uVar5 = 0;
if (0 < (long)uVar6) {
uVar5 = uVar6;
}
}
return uVar5;
}
| |
51,269 | end_key_cache_internal | eloqsql/mysys/mf_keycache.c | static
void end_key_cache_internal(KEY_CACHE *keycache, my_bool cleanup,
my_bool use_op_lock)
{
if (keycache->key_cache_inited)
{
keycache->interface_funcs->end(keycache->keycache_cb, cleanup);
if (cleanup)
{
if (keycache->keycache_cb)
{
my_free(keycache->keycache_cb);
keycache->keycache_cb= 0;
}
/*
We do not destroy op_lock if we are going to reuse the same key cache.
This happens if we are called from repartition_key_cache_internal().
*/
if (use_op_lock)
pthread_mutex_destroy(&keycache->op_lock);
keycache->key_cache_inited= 0;
}
keycache->can_be_used= 0;
}
} | O3 | c | end_key_cache_internal:
cmpb $0x0, 0x48(%rdi)
je 0x9b513
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rax
movsbl %sil, %r15d
movl %r15d, %esi
callq *0x40(%rax)
testb %r15b, %r15b
je 0x9b505
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x9b4f3
callq 0xa2e9e
movq $0x0, 0x8(%rbx)
testb %r14b, %r14b
je 0x9b501
leaq 0x58(%rbx), %rdi
callq 0x290c0
movb $0x0, 0x48(%rbx)
movb $0x0, 0x49(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| end_key_cache_internal:
cmp byte ptr [rdi+48h], 0
jz short locret_9B513
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14d, edx
mov rbx, rdi
mov rdi, [rdi+8]
mov rax, [rbx+10h]
movsx r15d, sil
mov esi, r15d
call qword ptr [rax+40h]
test r15b, r15b
jz short loc_9B505
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_9B4F3
call my_free
mov qword ptr [rbx+8], 0
loc_9B4F3:
test r14b, r14b
jz short loc_9B501
lea rdi, [rbx+58h]
call _pthread_mutex_destroy
loc_9B501:
mov byte ptr [rbx+48h], 0
loc_9B505:
mov byte ptr [rbx+49h], 0
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
locret_9B513:
retn
| long long end_key_cache_internal(long long a1, char a2, char a3)
{
long long result; // rax
long long v6; // rdi
if ( *(_BYTE *)(a1 + 72) )
{
result = (*(long long ( **)(_QWORD, _QWORD))(*(_QWORD *)(a1 + 16) + 64LL))(
*(_QWORD *)(a1 + 8),
(unsigned int)a2);
if ( a2 )
{
v6 = *(_QWORD *)(a1 + 8);
if ( v6 )
{
result = my_free(v6);
*(_QWORD *)(a1 + 8) = 0LL;
}
if ( a3 )
result = pthread_mutex_destroy(a1 + 88);
*(_BYTE *)(a1 + 72) = 0;
}
*(_BYTE *)(a1 + 73) = 0;
}
return result;
}
| end_key_cache_internal:
CMP byte ptr [RDI + 0x48],0x0
JZ 0x0019b513
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,EDX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RBX + 0x10]
MOVSX R15D,SIL
MOV ESI,R15D
CALL qword ptr [RAX + 0x40]
TEST R15B,R15B
JZ 0x0019b505
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x0019b4f3
CALL 0x001a2e9e
MOV qword ptr [RBX + 0x8],0x0
LAB_0019b4f3:
TEST R14B,R14B
JZ 0x0019b501
LEA RDI,[RBX + 0x58]
CALL 0x001290c0
LAB_0019b501:
MOV byte ptr [RBX + 0x48],0x0
LAB_0019b505:
MOV byte ptr [RBX + 0x49],0x0
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
LAB_0019b513:
RET
|
void end_key_cache_internal(long param_1,char param_2,char param_3)
{
if (*(char *)(param_1 + 0x48) != '\0') {
(**(code **)(*(long *)(param_1 + 0x10) + 0x40))(*(int8 *)(param_1 + 8),(int)param_2);
if (param_2 != '\0') {
if (*(long *)(param_1 + 8) != 0) {
my_free();
*(int8 *)(param_1 + 8) = 0;
}
if (param_3 != '\0') {
pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x58));
}
*(int1 *)(param_1 + 0x48) = 0;
}
*(int1 *)(param_1 + 0x49) = 0;
}
return;
}
| |
51,270 | plutovg_matrix_map_rect | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-matrix.c | void plutovg_matrix_map_rect(const plutovg_matrix_t* matrix, const plutovg_rect_t* src, plutovg_rect_t* dst)
{
plutovg_point_t p[4];
p[0].x = src->x;
p[0].y = src->y;
p[1].x = src->x + src->w;
p[1].y = src->y;
p[2].x = src->x + src->w;
p[2].y = src->y + src->h;
p[3].x = src->x;
p[3].y = src->y + src->h;
plutovg_matrix_map_points(matrix, p, p, 4);
float l = p[0].x;
float t = p[0].y;
float r = p[0].x;
float b = p[0].y;
for(int i = 1; i < 4; i++) {
if(p[i].x < l) l = p[i].x;
if(p[i].x > r) r = p[i].x;
if(p[i].y < t) t = p[i].y;
if(p[i].y > b) b = p[i].y;
}
dst->x = l;
dst->y = t;
dst->w = r - l;
dst->h = b - t;
} | O1 | c | plutovg_matrix_map_rect:
movss (%rsi), %xmm0
movss %xmm0, -0x28(%rsp)
movss 0x4(%rsi), %xmm1
movss %xmm1, -0x24(%rsp)
movss 0x8(%rsi), %xmm2
addss %xmm0, %xmm2
movss %xmm2, -0x20(%rsp)
movss %xmm1, -0x1c(%rsp)
movss %xmm2, -0x18(%rsp)
addss 0xc(%rsi), %xmm1
movss %xmm1, -0x14(%rsp)
movss %xmm0, -0x10(%rsp)
movss %xmm1, -0xc(%rsp)
movss (%rdi), %xmm0
movss 0x4(%rdi), %xmm1
movss 0x8(%rdi), %xmm2
movss 0x10(%rdi), %xmm3
movss 0xc(%rdi), %xmm4
movss 0x14(%rdi), %xmm5
xorl %eax, %eax
movss -0x28(%rsp,%rax,8), %xmm6
movss -0x24(%rsp,%rax,8), %xmm7
movaps %xmm7, %xmm8
mulss %xmm2, %xmm8
movaps %xmm6, %xmm9
mulss %xmm0, %xmm9
addss %xmm8, %xmm9
addss %xmm3, %xmm9
movss %xmm9, -0x28(%rsp,%rax,8)
mulss %xmm4, %xmm7
mulss %xmm1, %xmm6
addss %xmm7, %xmm6
addss %xmm5, %xmm6
movss %xmm6, -0x24(%rsp,%rax,8)
incq %rax
cmpq $0x4, %rax
jne 0x280ed
movss -0x28(%rsp), %xmm1
movss -0x24(%rsp), %xmm0
movl $0x1, %eax
movaps %xmm0, %xmm2
movaps %xmm1, %xmm3
movaps %xmm3, %xmm4
movaps %xmm2, %xmm5
movaps %xmm1, %xmm2
movaps %xmm0, %xmm6
movss -0x28(%rsp,%rax,8), %xmm1
movss -0x24(%rsp,%rax,8), %xmm0
movaps %xmm1, %xmm3
minss %xmm4, %xmm3
maxss %xmm2, %xmm1
movaps %xmm0, %xmm2
minss %xmm5, %xmm2
maxss %xmm6, %xmm0
incq %rax
cmpq $0x4, %rax
jne 0x28152
movss %xmm3, (%rdx)
movss %xmm2, 0x4(%rdx)
subss %xmm3, %xmm1
movss %xmm1, 0x8(%rdx)
subss %xmm2, %xmm0
movss %xmm0, 0xc(%rdx)
retq
| plutovg_matrix_map_rect:
movss xmm0, dword ptr [rsi]
movss [rsp+var_28], xmm0
movss xmm1, dword ptr [rsi+4]
movss [rsp+var_24], xmm1
movss xmm2, dword ptr [rsi+8]
addss xmm2, xmm0
movss [rsp+var_20], xmm2
movss [rsp+var_1C], xmm1
movss [rsp+var_18], xmm2
addss xmm1, dword ptr [rsi+0Ch]
movss [rsp+var_14], xmm1
movss [rsp+var_10], xmm0
movss [rsp+var_C], xmm1
movss xmm0, dword ptr [rdi]
movss xmm1, dword ptr [rdi+4]
movss xmm2, dword ptr [rdi+8]
movss xmm3, dword ptr [rdi+10h]
movss xmm4, dword ptr [rdi+0Ch]
movss xmm5, dword ptr [rdi+14h]
xor eax, eax
loc_280ED:
movss xmm6, [rsp+rax*8+var_28]
movss xmm7, [rsp+rax*8+var_24]
movaps xmm8, xmm7
mulss xmm8, xmm2
movaps xmm9, xmm6
mulss xmm9, xmm0
addss xmm9, xmm8
addss xmm9, xmm3
movss [rsp+rax*8+var_28], xmm9
mulss xmm7, xmm4
mulss xmm6, xmm1
addss xmm6, xmm7
addss xmm6, xmm5
movss [rsp+rax*8+var_24], xmm6
inc rax
cmp rax, 4
jnz short loc_280ED
movss xmm1, [rsp+var_28]
movss xmm0, [rsp+var_24]
mov eax, 1
movaps xmm2, xmm0
movaps xmm3, xmm1
loc_28152:
movaps xmm4, xmm3
movaps xmm5, xmm2
movaps xmm2, xmm1
movaps xmm6, xmm0
movss xmm1, [rsp+rax*8+var_28]
movss xmm0, [rsp+rax*8+var_24]
movaps xmm3, xmm1
minss xmm3, xmm4
maxss xmm1, xmm2
movaps xmm2, xmm0
minss xmm2, xmm5
maxss xmm0, xmm6
inc rax
cmp rax, 4
jnz short loc_28152
movss dword ptr [rdx], xmm3
movss dword ptr [rdx+4], xmm2
subss xmm1, xmm3
movss dword ptr [rdx+8], xmm1
subss xmm0, xmm2
movss dword ptr [rdx+0Ch], xmm0
retn
| long long plutovg_matrix_map_rect(float *a1, float *a2, float *a3)
{
float v3; // xmm0_4
float v4; // xmm1_4
float v5; // xmm2_4
float v6; // xmm3_4
float v7; // xmm4_4
float v8; // xmm5_4
long long i; // rax
float v10; // xmm6_4
float v11; // xmm7_4
float v12; // xmm1_4
float v13; // xmm0_4
long long result; // rax
float v15; // xmm2_4
float v16; // xmm3_4
float v17; // [rsp+0h] [rbp-28h]
float v18; // [rsp+4h] [rbp-24h]
float v19; // [rsp+8h] [rbp-20h]
float v20; // [rsp+Ch] [rbp-1Ch]
float v21; // [rsp+10h] [rbp-18h]
float v22; // [rsp+14h] [rbp-14h]
float v23; // [rsp+18h] [rbp-10h]
float v24; // [rsp+1Ch] [rbp-Ch]
v17 = *a2;
v18 = a2[1];
v19 = a2[2] + v17;
v20 = v18;
v21 = v19;
v22 = v18 + a2[3];
v23 = v17;
v24 = v22;
v3 = *a1;
v4 = a1[1];
v5 = a1[2];
v6 = a1[4];
v7 = a1[3];
v8 = a1[5];
for ( i = 0LL; i != 4; ++i )
{
v10 = *(&v17 + 2 * i);
v11 = *(&v18 + 2 * i);
*(&v17 + 2 * i) = (float)((float)(v10 * v3) + (float)(v11 * v5)) + v6;
*(&v18 + 2 * i) = (float)((float)(v10 * v4) + (float)(v11 * v7)) + v8;
}
v12 = v17;
v13 = v18;
result = 1LL;
v15 = v18;
v16 = v17;
do
{
v16 = fminf(*(&v17 + 2 * result), v16);
v12 = fmaxf(*(&v17 + 2 * result), v12);
v15 = fminf(*(&v18 + 2 * result), v15);
v13 = fmaxf(*(&v18 + 2 * result++), v13);
}
while ( result != 4 );
*a3 = v16;
a3[1] = v15;
a3[2] = v12 - v16;
a3[3] = v13 - v15;
return result;
}
| plutovg_matrix_map_rect:
MOVSS XMM0,dword ptr [RSI]
MOVSS dword ptr [RSP + -0x28],XMM0
MOVSS XMM1,dword ptr [RSI + 0x4]
MOVSS dword ptr [RSP + -0x24],XMM1
MOVSS XMM2,dword ptr [RSI + 0x8]
ADDSS XMM2,XMM0
MOVSS dword ptr [RSP + -0x20],XMM2
MOVSS dword ptr [RSP + -0x1c],XMM1
MOVSS dword ptr [RSP + -0x18],XMM2
ADDSS XMM1,dword ptr [RSI + 0xc]
MOVSS dword ptr [RSP + -0x14],XMM1
MOVSS dword ptr [RSP + -0x10],XMM0
MOVSS dword ptr [RSP + -0xc],XMM1
MOVSS XMM0,dword ptr [RDI]
MOVSS XMM1,dword ptr [RDI + 0x4]
MOVSS XMM2,dword ptr [RDI + 0x8]
MOVSS XMM3,dword ptr [RDI + 0x10]
MOVSS XMM4,dword ptr [RDI + 0xc]
MOVSS XMM5,dword ptr [RDI + 0x14]
XOR EAX,EAX
LAB_001280ed:
MOVSS XMM6,dword ptr [RSP + RAX*0x8 + -0x28]
MOVSS XMM7,dword ptr [RSP + RAX*0x8 + -0x24]
MOVAPS XMM8,XMM7
MULSS XMM8,XMM2
MOVAPS XMM9,XMM6
MULSS XMM9,XMM0
ADDSS XMM9,XMM8
ADDSS XMM9,XMM3
MOVSS dword ptr [RSP + RAX*0x8 + -0x28],XMM9
MULSS XMM7,XMM4
MULSS XMM6,XMM1
ADDSS XMM6,XMM7
ADDSS XMM6,XMM5
MOVSS dword ptr [RSP + RAX*0x8 + -0x24],XMM6
INC RAX
CMP RAX,0x4
JNZ 0x001280ed
MOVSS XMM1,dword ptr [RSP + -0x28]
MOVSS XMM0,dword ptr [RSP + -0x24]
MOV EAX,0x1
MOVAPS XMM2,XMM0
MOVAPS XMM3,XMM1
LAB_00128152:
MOVAPS XMM4,XMM3
MOVAPS XMM5,XMM2
MOVAPS XMM2,XMM1
MOVAPS XMM6,XMM0
MOVSS XMM1,dword ptr [RSP + RAX*0x8 + -0x28]
MOVSS XMM0,dword ptr [RSP + RAX*0x8 + -0x24]
MOVAPS XMM3,XMM1
MINSS XMM3,XMM4
MAXSS XMM1,XMM2
MOVAPS XMM2,XMM0
MINSS XMM2,XMM5
MAXSS XMM0,XMM6
INC RAX
CMP RAX,0x4
JNZ 0x00128152
MOVSS dword ptr [RDX],XMM3
MOVSS dword ptr [RDX + 0x4],XMM2
SUBSS XMM1,XMM3
MOVSS dword ptr [RDX + 0x8],XMM1
SUBSS XMM0,XMM2
MOVSS dword ptr [RDX + 0xc],XMM0
RET
|
void plutovg_matrix_map_rect(float *param_1,float *param_2,float *param_3)
{
float fVar1;
float fVar2;
long lVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
float fVar8;
float fVar9;
float local_28 [10];
local_28[0] = *param_2;
local_28[1] = param_2[1];
local_28[2] = param_2[2] + local_28[0];
local_28[3] = local_28[1];
local_28[4] = param_2[2] + local_28[0];
local_28[5] = local_28[1] + param_2[3];
local_28[6] = local_28[0];
local_28[7] = local_28[1] + param_2[3];
fVar6 = *param_1;
fVar8 = param_1[1];
fVar5 = param_1[2];
fVar4 = param_1[4];
fVar9 = param_1[3];
fVar7 = param_1[5];
lVar3 = 0;
do {
fVar1 = local_28[lVar3 * 2];
fVar2 = local_28[lVar3 * 2 + 1];
local_28[lVar3 * 2] = fVar1 * fVar6 + fVar2 * fVar5 + fVar4;
local_28[lVar3 * 2 + 1] = fVar1 * fVar8 + fVar2 * fVar9 + fVar7;
lVar3 = lVar3 + 1;
} while (lVar3 != 4);
lVar3 = 1;
fVar6 = local_28[1];
fVar8 = local_28[0];
do {
fVar5 = local_28[lVar3 * 2];
fVar4 = local_28[lVar3 * 2 + 1];
fVar9 = fVar5;
if (fVar8 <= fVar5) {
fVar9 = fVar8;
}
if (fVar5 <= local_28[0]) {
fVar5 = local_28[0];
}
fVar7 = fVar4;
if (fVar6 <= fVar4) {
fVar7 = fVar6;
}
if (fVar4 <= local_28[1]) {
fVar4 = local_28[1];
}
lVar3 = lVar3 + 1;
local_28[1] = fVar4;
local_28[0] = fVar5;
fVar6 = fVar7;
fVar8 = fVar9;
} while (lVar3 != 4);
*param_3 = fVar9;
param_3[1] = fVar7;
param_3[2] = fVar5 - fVar9;
param_3[3] = fVar4 - fVar7;
return;
}
| |
51,271 | plutovg_matrix_map_rect | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-matrix.c | void plutovg_matrix_map_rect(const plutovg_matrix_t* matrix, const plutovg_rect_t* src, plutovg_rect_t* dst)
{
plutovg_point_t p[4];
p[0].x = src->x;
p[0].y = src->y;
p[1].x = src->x + src->w;
p[1].y = src->y;
p[2].x = src->x + src->w;
p[2].y = src->y + src->h;
p[3].x = src->x;
p[3].y = src->y + src->h;
plutovg_matrix_map_points(matrix, p, p, 4);
float l = p[0].x;
float t = p[0].y;
float r = p[0].x;
float b = p[0].y;
for(int i = 1; i < 4; i++) {
if(p[i].x < l) l = p[i].x;
if(p[i].x > r) r = p[i].x;
if(p[i].y < t) t = p[i].y;
if(p[i].y > b) b = p[i].y;
}
dst->x = l;
dst->y = t;
dst->w = r - l;
dst->h = b - t;
} | O2 | c | plutovg_matrix_map_rect:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movsd (%rsi), %xmm0
movq %rsp, %r14
movsd %xmm0, (%r14)
movsd 0x8(%rsi), %xmm1
addps %xmm0, %xmm1
movss %xmm1, 0x8(%r14)
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2 # xmm2 = xmm2[1,1],xmm0[1,1]
movss %xmm2, 0xc(%r14)
movlps %xmm1, 0x10(%r14)
movss %xmm0, 0x18(%r14)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movss %xmm1, 0x1c(%r14)
pushq $0x4
popq %rcx
movq %r14, %rsi
movq %r14, %rdx
callq 0x23df8
pushq $0x1
popq %rax
movsd (%r14), %xmm0
movaps %xmm0, %xmm1
cmpq $0x4, %rax
je 0x23eba
movsd (%rsp,%rax,8), %xmm2
movaps %xmm2, %xmm3
minps %xmm0, %xmm3
maxps %xmm1, %xmm2
incq %rax
movaps %xmm3, %xmm0
movaps %xmm2, %xmm1
jmp 0x23e9b
subps %xmm0, %xmm1
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| plutovg_matrix_map_rect:
push r14
push rbx
sub rsp, 28h
mov rbx, rdx
movsd xmm0, qword ptr [rsi]
mov r14, rsp
movsd qword ptr [r14], xmm0
movsd xmm1, qword ptr [rsi+8]
addps xmm1, xmm0
movss dword ptr [r14+8], xmm1
movaps xmm2, xmm0
shufps xmm2, xmm0, 55h ; 'U'
movss dword ptr [r14+0Ch], xmm2
movlps qword ptr [r14+10h], xmm1
movss dword ptr [r14+18h], xmm0
shufps xmm1, xmm1, 55h ; 'U'
movss dword ptr [r14+1Ch], xmm1
push 4
pop rcx
mov rsi, r14
mov rdx, r14
call plutovg_matrix_map_points
push 1
pop rax
movsd xmm0, qword ptr [r14]
movaps xmm1, xmm0
loc_23E9B:
cmp rax, 4
jz short loc_23EBA
movsd xmm2, [rsp+rax*8+38h+var_38]
movaps xmm3, xmm2
minps xmm3, xmm0
maxps xmm2, xmm1
inc rax
movaps xmm0, xmm3
movaps xmm1, xmm2
jmp short loc_23E9B
loc_23EBA:
subps xmm1, xmm0
movlhps xmm0, xmm1
movups xmmword ptr [rbx], xmm0
add rsp, 28h
pop rbx
pop r14
retn
| long long plutovg_matrix_map_rect(float *a1, unsigned long long *a2, __m128 *a3)
{
__m128 v4; // xmm0
__m128 v5; // xmm1
long long result; // rax
__m128 v7; // xmm0
__m128 v8; // xmm1
__m128 v9; // xmm3
__m128 v10; // xmm2
unsigned long long v11; // [rsp+0h] [rbp-38h] BYREF
__int32 v12; // [rsp+8h] [rbp-30h]
unsigned __int32 v13; // [rsp+Ch] [rbp-2Ch]
double v14; // [rsp+10h] [rbp-28h] BYREF
__int32 v15; // [rsp+18h] [rbp-20h]
unsigned __int32 v16; // [rsp+1Ch] [rbp-1Ch]
v11 = *a2;
v4 = (__m128)v11;
v5 = _mm_add_ps((__m128)a2[1], (__m128)v11);
v12 = v5.m128_i32[0];
v13 = _mm_shuffle_ps(v4, v4, 85).m128_u32[0];
_mm_storel_ps(&v14, v5);
v15 = v4.m128_i32[0];
v16 = _mm_shuffle_ps(v5, v5, 85).m128_u32[0];
plutovg_matrix_map_points(a1, (float *)&v11, (float *)&v11, 4);
result = 1LL;
v7 = (__m128)v11;
v8 = (__m128)v11;
while ( result != 4 )
{
v9 = _mm_min_ps((__m128)*(&v11 + result), v7);
v10 = _mm_max_ps((__m128)*(&v11 + result++), v8);
v7 = v9;
v8 = v10;
}
*a3 = _mm_movelh_ps(v7, _mm_sub_ps(v8, v7));
return result;
}
| plutovg_matrix_map_rect:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDX
MOVSD XMM0,qword ptr [RSI]
MOV R14,RSP
MOVSD qword ptr [R14],XMM0
MOVSD XMM1,qword ptr [RSI + 0x8]
ADDPS XMM1,XMM0
MOVSS dword ptr [R14 + 0x8],XMM1
MOVAPS XMM2,XMM0
SHUFPS XMM2,XMM0,0x55
MOVSS dword ptr [R14 + 0xc],XMM2
MOVLPS qword ptr [R14 + 0x10],XMM1
MOVSS dword ptr [R14 + 0x18],XMM0
SHUFPS XMM1,XMM1,0x55
MOVSS dword ptr [R14 + 0x1c],XMM1
PUSH 0x4
POP RCX
MOV RSI,R14
MOV RDX,R14
CALL 0x00123df8
PUSH 0x1
POP RAX
MOVSD XMM0,qword ptr [R14]
MOVAPS XMM1,XMM0
LAB_00123e9b:
CMP RAX,0x4
JZ 0x00123eba
MOVSD XMM2,qword ptr [RSP + RAX*0x8]
MOVAPS XMM3,XMM2
MINPS XMM3,XMM0
MAXPS XMM2,XMM1
INC RAX
MOVAPS XMM0,XMM3
MOVAPS XMM1,XMM2
JMP 0x00123e9b
LAB_00123eba:
SUBPS XMM1,XMM0
MOVLHPS XMM0,XMM1
MOVUPS xmmword ptr [RBX],XMM0
ADD RSP,0x28
POP RBX
POP R14
RET
|
void plutovg_matrix_map_rect(int8 param_1,ulong *param_2,float *param_3)
{
int1 auVar1 [16];
long lVar2;
float fVar3;
float fVar4;
int4 uVar5;
int4 uVar6;
float fVar7;
float fVar8;
int4 uVar9;
int4 uVar10;
int1 auVar11 [16];
int1 auVar12 [16];
int1 auVar13 [16];
ulong local_38;
float local_30;
float fStack_2c;
int8 local_28;
float local_20;
float local_1c;
local_38 = *param_2;
local_20 = (float)local_38;
fStack_2c = (float)(local_38 >> 0x20);
local_30 = (float)param_2[1] + local_20;
local_1c = (float)(param_2[1] >> 0x20) + fStack_2c;
local_28 = CONCAT44(local_1c,local_30);
plutovg_matrix_map_points(param_1,&local_38,&local_38,4);
fVar3 = (float)local_38;
fVar4 = (float)(local_38 >> 0x20);
uVar5 = 0;
uVar6 = 0;
fVar7 = fVar3;
fVar8 = fVar4;
uVar9 = uVar5;
uVar10 = uVar6;
for (lVar2 = 1; lVar2 != 4; lVar2 = lVar2 + 1) {
auVar11._8_8_ = 0;
auVar11._0_8_ = (&local_38)[lVar2];
auVar13._8_8_ = 0;
auVar13._0_8_ = (&local_38)[lVar2];
auVar12._4_4_ = fVar4;
auVar12._0_4_ = fVar3;
auVar12._8_4_ = uVar5;
auVar12._12_4_ = uVar6;
auVar13 = minps(auVar13,auVar12);
auVar1._4_4_ = fVar8;
auVar1._0_4_ = fVar7;
auVar1._8_4_ = uVar9;
auVar1._12_4_ = uVar10;
auVar12 = maxps(auVar11,auVar1);
fVar3 = auVar13._0_4_;
fVar4 = auVar13._4_4_;
uVar5 = auVar13._8_4_;
uVar6 = auVar13._12_4_;
fVar7 = auVar12._0_4_;
fVar8 = auVar12._4_4_;
uVar9 = auVar12._8_4_;
uVar10 = auVar12._12_4_;
}
*param_3 = fVar3;
param_3[1] = fVar4;
param_3[2] = fVar7 - fVar3;
param_3[3] = fVar8 - fVar4;
return;
}
| |
51,272 | directory_file_name | eloqsql/mysys/my_lib.c | static char *directory_file_name (char * dst, const char *src)
{
/* Process as Unix format: just remove test the final slash. */
char *end;
DBUG_ASSERT(strlen(src) < (FN_REFLEN + 1));
if (src[0] == 0)
src= (char*) "."; /* Use empty as current */
end= strnmov(dst, src, FN_REFLEN + 1);
if (end[-1] != FN_LIBCHAR)
{
*end++= FN_LIBCHAR; /* Add last '/' */
*end='\0';
}
return end;
} | O0 | c | directory_file_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xf4702
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xf4719
leaq 0x60dfa(%rip), %rax # 0x15550f
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x201, %edx # imm = 0x201
callq 0x14f250
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0xf4755
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x2f, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| directory_file_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_F4702:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_F4719
lea rax, asc_15550E+1; "."
mov [rbp+var_10], rax
loc_F4719:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 201h
call strnmov
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_F4755
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov byte ptr [rax], 2Fh ; '/'
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
loc_F4755:
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
| _BYTE * directory_file_name(long long a1, char *a2)
{
_BYTE *v2; // rax
_BYTE *v4; // [rsp+8h] [rbp-18h]
char *v5; // [rsp+10h] [rbp-10h]
v5 = a2;
if ( !*a2 )
v5 = ".";
v4 = (_BYTE *)strnmov(a1, v5, 513LL);
if ( *(v4 - 1) != 47 )
{
v2 = v4++;
*v2 = 47;
*v4 = 0;
}
return v4;
}
| directory_file_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001f4702
LAB_001f4702:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x001f4719
LEA RAX,[0x25550f]
MOV qword ptr [RBP + -0x10],RAX
LAB_001f4719:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x201
CALL 0x0024f250
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x001f4755
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV byte ptr [RAX],0x2f
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
LAB_001f4755:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
int1 * directory_file_name(int8 param_1,char *param_2)
{
int1 *puVar1;
int1 *local_20;
char *local_18;
local_18 = param_2;
if (*param_2 == '\0') {
local_18 = ".";
}
puVar1 = (int1 *)strnmov(param_1,local_18,0x201);
local_20 = puVar1;
if (puVar1[-1] != '/') {
local_20 = puVar1 + 1;
*puVar1 = 0x2f;
*local_20 = 0;
}
return local_20;
}
| |
51,273 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++() | monkey531[P]llama/common/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
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:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
jne 0x120b7a
leaq 0xf461e(%rip), %rdi # 0x21517e
movl $0x33c0, %esi # imm = 0x33C0
leaq 0xee504(%rip), %rdx # 0x20f070
leaq 0xf9d21(%rip), %rcx # 0x21a894
movb $0x0, %al
callq 0x5def0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq %rax, (%rsp)
subq $0x9, %rax
ja 0x120bd3
movq (%rsp), %rax
leaq 0xf7196(%rip), %rcx # 0x217d30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb87c0
jmp 0x120be5
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb8810
jmp 0x120be5
jmp 0x120bd3
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0xb8860
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rax, [rsp+18h+var_8]
mov [rsp+18h+var_10], rax
cmp qword ptr [rax], 0
jnz short loc_120B7A
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 33C0h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov al, 0
call _ggml_abort
loc_120B7A:
mov rax, [rsp+18h+var_10]
mov rax, [rax]
movzx eax, byte ptr [rax]
mov [rsp+18h+var_18], rax
sub rax, 9; switch 10 cases
ja short def_120BA1; jumptable 0000000000120BA1 default case
mov rax, [rsp+18h+var_18]
lea rcx, jpt_120BA1
movsxd rax, ds:(jpt_120BA1 - 217D30h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_120BA3:
mov rdi, [rsp+18h+var_10]; jumptable 0000000000120BA1 case 1
add rdi, 8
mov esi, 1
call _ZSt7advanceIN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSB_11ordered_mapESt6vectorS8_blmdSaNSB_14adl_serializerESE_IhSaIhEEvEEESE_ISJ_SaISJ_EEEEiEvRT_T0_; std::advance<__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>,int>(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> &,int)
jmp short loc_120BE5
loc_120BB8:
mov rdi, [rsp+18h+var_10]; jumptable 0000000000120BA1 case 2
add rdi, 8
add rdi, 8
mov esi, 1
call _ZSt7advanceIN9__gnu_cxx17__normal_iteratorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEES6_ISG_SaISG_EEEEiEvRT_T0_; std::advance<__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::vector<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>>>,int>(__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::vector<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>>> &,int)
jmp short loc_120BE5
loc_120BD1:
jmp short $+2; jumptable 0000000000120BA1 cases 0,3-9
def_120BA1:
mov rdi, [rsp+18h+var_10]; jumptable 0000000000120BA1 default case
add rdi, 8
add rdi, 10h
call _ZN8nlohmann16json_abi_v3_11_36detail20primitive_iterator_tppEv; nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::operator++(void)
loc_120BE5:
mov rax, [rsp+18h+var_10]
add rsp, 18h
retn
| _QWORD * nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(
_QWORD *a1)
{
if ( !*a1 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
13248LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
switch ( *(_BYTE *)*a1 )
{
case 1:
std::advance<__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>,int>(
(long long)(a1 + 1),
1);
break;
case 2:
std::advance<__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::vector<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>>>,int>(
(long long)(a1 + 2),
1);
break;
default:
nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::operator++(a1 + 3);
break;
}
return a1;
}
| |||
51,274 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++() | monkey531[P]llama/common/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
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:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++():
movq (%rdi), %rax
testq %rax, %rax
je 0x67d49
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x67d3a
cmpl $0x1, %eax
jne 0x67d41
addq $0x30, 0x8(%rdi)
jmp 0x67d45
addq $0x10, 0x10(%rdi)
jmp 0x67d45
incq 0x18(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x49e95(%rip), %rdi # 0xb1be6
leaq 0x443e8(%rip), %rdx # 0xac140
leaq 0x4f14e(%rip), %rcx # 0xb6ead
movl $0x33c0, %esi # imm = 0x33C0
xorl %eax, %eax
callq 0x24e90
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
mov rax, [rdi]
test rax, rax
jz short loc_67D49
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_67D3A
cmp eax, 1
jnz short loc_67D41
add qword ptr [rdi+8], 30h ; '0'
jmp short loc_67D45
loc_67D3A:
add qword ptr [rdi+10h], 10h
jmp short loc_67D45
loc_67D41:
inc qword ptr [rdi+18h]
loc_67D45:
mov rax, rdi
retn
loc_67D49:
push rax
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 33C0h
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(
unsigned __int8 **a1)
{
int v1; // eax
if ( *a1 )
{
v1 = **a1;
if ( v1 == 2 )
{
a1[2] += 16;
}
else if ( v1 == 1 )
{
a1[1] += 48;
}
else
{
++a1[3];
}
return (long long)a1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
13248LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
return std::make_shared<std::vector<minja::Value>>(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
13248LL);
}
}
| operator++:
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00167d49
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x00167d3a
CMP EAX,0x1
JNZ 0x00167d41
ADD qword ptr [RDI + 0x8],0x30
JMP 0x00167d45
LAB_00167d3a:
ADD qword ptr [RDI + 0x10],0x10
JMP 0x00167d45
LAB_00167d41:
INC qword ptr [RDI + 0x18]
LAB_00167d45:
MOV RAX,RDI
RET
LAB_00167d49:
PUSH RAX
LEA RDI,[0x1b1be6]
LEA RDX,[0x1ac140]
LEA RCX,[0x1b6ead]
MOV ESI,0x33c0
XOR EAX,EAX
CALL 0x00124e90
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*this)
{
char cVar1;
int8 in_R8;
int8 in_R9;
if (*(char **)this != (char *)0x0) {
cVar1 = **(char **)this;
if (cVar1 == '\x02') {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 0x10;
}
else if (cVar1 == '\x01') {
*(long *)(this + 8) = *(long *)(this + 8) + 0x30;
}
else {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
return this;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x33c0,
"GGML_ASSERT(%s) failed","m_object != nullptr",in_R8,in_R9,0);
}
| |
51,275 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++() | monkey531[P]llama/common/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
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:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++():
movq (%rdi), %rax
testq %rax, %rax
je 0x8c849
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x8c83a
cmpl $0x1, %eax
jne 0x8c841
addq $0x30, 0x8(%rdi)
jmp 0x8c845
addq $0x10, 0x10(%rdi)
jmp 0x8c845
incq 0x18(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x61392(%rip), %rdi # 0xedbe3
leaq 0x5b8e8(%rip), %rdx # 0xe8140
leaq 0x6665e(%rip), %rcx # 0xf2ebd
movl $0x33c0, %esi # imm = 0x33C0
xorl %eax, %eax
callq 0x1be80
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
mov rax, [rdi]
test rax, rax
jz short loc_8C849
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_8C83A
cmp eax, 1
jnz short loc_8C841
add qword ptr [rdi+8], 30h ; '0'
jmp short loc_8C845
loc_8C83A:
add qword ptr [rdi+10h], 10h
jmp short loc_8C845
loc_8C841:
inc qword ptr [rdi+18h]
loc_8C845:
mov rax, rdi
retn
loc_8C849:
push rax
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 33C0h
xor eax, eax
call _ggml_abort
nop
| long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(
unsigned __int8 **a1)
{
int v1; // eax
if ( *a1 )
{
v1 = **a1;
if ( v1 == 2 )
{
a1[2] += 16;
}
else if ( v1 == 1 )
{
a1[1] += 48;
}
else
{
++a1[3];
}
return (long long)a1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
13248LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
return nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
}
| operator++:
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0018c849
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x0018c83a
CMP EAX,0x1
JNZ 0x0018c841
ADD qword ptr [RDI + 0x8],0x30
JMP 0x0018c845
LAB_0018c83a:
ADD qword ptr [RDI + 0x10],0x10
JMP 0x0018c845
LAB_0018c841:
INC qword ptr [RDI + 0x18]
LAB_0018c845:
MOV RAX,RDI
RET
LAB_0018c849:
PUSH RAX
LEA RDI,[0x1edbe3]
LEA RDX,[0x1e8140]
LEA RCX,[0x1f2ebd]
MOV ESI,0x33c0
XOR EAX,EAX
CALL 0x0011be80
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*this)
{
char cVar1;
int8 in_R8;
int8 in_R9;
if (*(char **)this != (char *)0x0) {
cVar1 = **(char **)this;
if (cVar1 == '\x02') {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 0x10;
}
else if (cVar1 == '\x01') {
*(long *)(this + 8) = *(long *)(this + 8) + 0x30;
}
else {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
return this;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x33c0,
"GGML_ASSERT(%s) failed","m_object != nullptr",in_R8,in_R9,0);
}
| |
51,276 | nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, parse_json(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)::json_error_locator>::get_cbor_array(unsigned long, nlohmann::json_abi_v3_11_3::detail::cbor_tag_handler_t) | monkey531[P]llama/common/./json.hpp | bool get_cbor_array(const std::size_t len,
const cbor_tag_handler_t tag_handler)
{
if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
{
return false;
}
if (len != static_cast<std::size_t>(-1))
{
for (std::size_t i = 0; i < len; ++i)
{
if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
{
return false;
}
}
}
else
{
while (get() != 0xFF)
{
if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
{
return false;
}
}
}
return sax->end_array();
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, parse_json(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)::json_error_locator>::get_cbor_array(unsigned long, nlohmann::json_abi_v3_11_3::detail::cbor_tag_handler_t):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x50(%rax)
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1b0657
jmp 0x1b0661
movb $0x0, 0x37(%rsp)
jmp 0x1b0707
cmpq $-0x1, 0x20(%rsp)
je 0x1b06b8
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x1b06b6
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl $0x1, %esi
callq 0x1ab630
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1b069d
jmp 0x1b06a4
movb $0x0, 0x37(%rsp)
jmp 0x1b0707
jmp 0x1b06a6
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1b0672
jmp 0x1b06f2
jmp 0x1b06ba
movq 0x8(%rsp), %rdi
callq 0x1adc50
cmpl $0xff, %eax
je 0x1b06f0
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %edx
xorl %esi, %esi
callq 0x1ab630
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1b06e7
jmp 0x1b06ee
movb $0x0, 0x37(%rsp)
jmp 0x1b0707
jmp 0x1b06ba
jmp 0x1b06f2
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE14get_cbor_arrayEmNS1_18cbor_tag_handler_tE:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_1C], edx
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_30], rax
mov rdi, [rax+28h]
mov rsi, [rsp+38h+var_18]
mov rax, [rdi]
call qword ptr [rax+50h]
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1B0657
jmp short loc_1B0661
loc_1B0657:
mov [rsp+38h+var_1], 0
jmp loc_1B0707
loc_1B0661:
cmp [rsp+38h+var_18], 0FFFFFFFFFFFFFFFFh
jz short loc_1B06B8
mov [rsp+38h+var_28], 0
loc_1B0672:
mov rax, [rsp+38h+var_28]
cmp rax, [rsp+38h+var_18]
jnb short loc_1B06B6
mov rdi, [rsp+38h+var_30]
mov edx, [rsp+38h+var_1C]
mov esi, 1
call _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE19parse_cbor_internalEbNS1_18cbor_tag_handler_tE; nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::parse_cbor_internal(bool,nlohmann::json_abi_v3_11_3::detail::cbor_tag_handler_t)
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1B069D
jmp short loc_1B06A4
loc_1B069D:
mov [rsp+38h+var_1], 0
jmp short loc_1B0707
loc_1B06A4:
jmp short $+2
loc_1B06A6:
mov rax, [rsp+38h+var_28]
add rax, 1
mov [rsp+38h+var_28], rax
jmp short loc_1B0672
loc_1B06B6:
jmp short loc_1B06F2
loc_1B06B8:
jmp short $+2
loc_1B06BA:
mov rdi, [rsp+38h+var_30]
call _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE3getEv; nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::get(void)
cmp eax, 0FFh
jz short loc_1B06F0
mov rdi, [rsp+38h+var_30]
mov edx, [rsp+38h+var_1C]
xor esi, esi
call _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE19parse_cbor_internalEbNS1_18cbor_tag_handler_tE; nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::parse_cbor_internal(bool,nlohmann::json_abi_v3_11_3::detail::cbor_tag_handler_t)
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1B06E7
jmp short loc_1B06EE
loc_1B06E7:
mov [rsp+38h+var_1], 0
jmp short loc_1B0707
loc_1B06EE:
jmp short loc_1B06BA
loc_1B06F0:
jmp short $+2
loc_1B06F2:
mov rax, [rsp+38h+var_30]
mov rdi, [rax+28h]
mov rax, [rdi]
call qword ptr [rax+58h]
and al, 1
mov [rsp+38h+var_1], al
loc_1B0707:
mov al, [rsp+38h+var_1]
and al, 1
add rsp, 38h
retn
| char nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::get_cbor_array(
long long a1,
unsigned long long a2,
unsigned int a3)
{
long long v3; // rcx
int v4; // r8d
int v5; // r9d
long long v6; // rcx
int v7; // r8d
int v8; // r9d
unsigned long long i; // [rsp+10h] [rbp-28h]
if ( ((*(long long ( **)(_QWORD, unsigned long long))(**(_QWORD **)(a1 + 40) + 80LL))(*(_QWORD *)(a1 + 40), a2) & 1) == 0 )
return 0;
if ( a2 == -1LL )
{
while ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::get(a1) != 255 )
{
if ( (nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::parse_cbor_internal(
a1,
0,
a3,
v6,
v7,
v8) & 1) == 0 )
return 0;
}
}
else
{
for ( i = 0LL; i < a2; ++i )
{
if ( (nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,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>&)::json_error_locator>::parse_cbor_internal(
a1,
1,
a3,
v3,
v4,
v5) & 1) == 0 )
return 0;
}
}
return (*(long long ( **)(_QWORD))(**(_QWORD **)(a1 + 40) + 88LL))(*(_QWORD *)(a1 + 40)) & 1;
}
| get_sql_field_type:
SUB RSP,0x58
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x001a9540
MOV ECX,EAX
MOV dword ptr [RSP + 0x2c],ECX
TEST EAX,EAX
JZ 0x001b0670
JMP 0x001b0651
LAB_001b0651:
MOV EAX,dword ptr [RSP + 0x2c]
DEC EAX
SUB EAX,0x2
JC 0x001b06c3
JMP 0x001b065e
LAB_001b065e:
MOV EAX,dword ptr [RSP + 0x2c]
SUB EAX,0x3
JZ 0x001b0710
JMP 0x001b075b
LAB_001b0670:
LEA RDI,[RSP + 0x47]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00156f00
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001b0689:
LEA RSI,[0x2e4a74]
CALL 0x00166600
JMP 0x001b0697
LAB_001b0697:
LEA RDI,[RSP + 0x47]
CALL 0x001572b0
JMP 0x001b0765
LAB_001b06c3:
LEA RDI,[RSP + 0x33]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00156f00
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x8]
LAB_001b06dc:
LEA RSI,[0x2e4a79]
CALL 0x00166600
JMP 0x001b06ea
LAB_001b06ea:
LEA RDI,[RSP + 0x33]
CALL 0x001572b0
JMP 0x001b0765
LAB_001b0710:
LEA RDI,[RSP + 0x32]
MOV qword ptr [RSP],RDI
CALL 0x00156f00
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP]
LAB_001b0727:
LEA RSI,[0x2e4a81]
CALL 0x00166600
LAB_001b0733:
JMP 0x001b0735
LAB_001b0735:
LEA RDI,[RSP + 0x32]
CALL 0x001572b0
JMP 0x001b0765
LAB_001b075b:
MOV EDI,0x1
CALL 0x00156a70
LAB_001b0765:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x58
RET
|
/* sql_printer::get_sql_field_type(std::__cxx11::string const&) */
sql_printer * __thiscall sql_printer::get_sql_field_type(sql_printer *this,string *param_1)
{
int iVar1;
allocator local_26;
allocator local_25 [20];
allocator local_11;
string *local_10;
sql_printer *local_8;
local_10 = param_1;
local_8 = this;
iVar1 = test::get_field_type(param_1);
if (iVar1 == 0) {
std::allocator<char>::allocator();
/* try { // try from 001b0689 to 001b0694 has its CatchHandler @ 001b06a6 */
std::__cxx11::string::string<std::allocator<char>>((string *)this,"TEXT",&local_11);
std::allocator<char>::~allocator((allocator<char> *)&local_11);
}
else if (iVar1 - 1U < 2) {
std::allocator<char>::allocator();
/* try { // try from 001b06dc to 001b06e7 has its CatchHandler @ 001b06f6 */
std::__cxx11::string::string<std::allocator<char>>((string *)this,"INTEGER",local_25);
std::allocator<char>::~allocator((allocator<char> *)local_25);
}
else {
if (iVar1 != 3) {
/* WARNING: Subroutine does not return */
exit(1);
}
std::allocator<char>::allocator();
/* try { // try from 001b0727 to 001b0732 has its CatchHandler @ 001b0741 */
std::__cxx11::string::string<std::allocator<char>>((string *)this,"REAL",&local_26);
std::allocator<char>::~allocator((allocator<char> *)&local_26);
}
return this;
}
| |
51,277 | remove_reader | eloqsql/storage/maria/ma_pagecache.c | static inline void remove_reader(PAGECACHE_BLOCK_LINK *block)
{
DBUG_ENTER("remove_reader");
PCBLOCK_INFO(block);
DBUG_ASSERT(block->hash_link->requests > 0);
if (! --block->hash_link->requests && block->condvar)
pagecache_pthread_cond_signal(block->condvar);
DBUG_VOID_RETURN;
} | O0 | c | remove_reader:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x9b83e
jmp 0x9b840
jmp 0x9b842
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movl 0x68(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x68(%rcx)
cmpl $0x0, %eax
jne 0x9b870
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x9b870
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x9f280
jmp 0x9b872
jmp 0x9b874
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| remove_reader:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_9B83E:
jmp short $+2
loc_9B840:
jmp short $+2
loc_9B842:
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
mov eax, [rcx+68h]
add eax, 0FFFFFFFFh
mov [rcx+68h], eax
cmp eax, 0
jnz short loc_9B870
mov rax, [rbp+var_8]
cmp qword ptr [rax+28h], 0
jz short loc_9B870
mov rax, [rbp+var_8]
mov rdi, [rax+28h]
call inline_mysql_cond_signal_0
loc_9B870:
jmp short $+2
loc_9B872:
jmp short $+2
loc_9B874:
add rsp, 10h
pop rbp
retn
| long long remove_reader(long long a1)
{
long long v1; // rcx
long long result; // rax
v1 = *(_QWORD *)(a1 + 32);
result = (unsigned int)(*(_DWORD *)(v1 + 104) - 1);
*(_DWORD *)(v1 + 104) = result;
if ( !(_DWORD)result )
{
result = a1;
if ( *(_QWORD *)(a1 + 40) )
return inline_mysql_cond_signal_0(*(_QWORD *)(a1 + 40));
}
return result;
}
| remove_reader:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0019b83e
LAB_0019b83e:
JMP 0x0019b840
LAB_0019b840:
JMP 0x0019b842
LAB_0019b842:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
MOV EAX,dword ptr [RCX + 0x68]
ADD EAX,-0x1
MOV dword ptr [RCX + 0x68],EAX
CMP EAX,0x0
JNZ 0x0019b870
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x28],0x0
JZ 0x0019b870
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x28]
CALL 0x0019f280
LAB_0019b870:
JMP 0x0019b872
LAB_0019b872:
JMP 0x0019b874
LAB_0019b874:
ADD RSP,0x10
POP RBP
RET
|
void remove_reader(long param_1)
{
int iVar1;
iVar1 = *(int *)(*(long *)(param_1 + 0x20) + 0x68) + -1;
*(int *)(*(long *)(param_1 + 0x20) + 0x68) = iVar1;
if ((iVar1 == 0) && (*(long *)(param_1 + 0x28) != 0)) {
inline_mysql_cond_signal(*(int8 *)(param_1 + 0x28));
}
return;
}
| |
51,278 | seek_io_cache | eloqsql/mysys/mf_iocache.c | void seek_io_cache(IO_CACHE *cache, my_off_t needed_offset)
{
my_off_t cached_data_start= cache->pos_in_file;
my_off_t cached_data_end= cache->pos_in_file + (cache->read_end -
cache->buffer);
if (needed_offset >= cached_data_start &&
needed_offset < cached_data_end)
{
/*
The offset we're seeking to is in the buffer.
Move buffer's read position accordingly
*/
cache->read_pos= cache->buffer + (needed_offset - cached_data_start);
}
else
{
if (needed_offset > cache->end_of_file)
needed_offset= cache->end_of_file;
/*
The offset we're seeking to is not in the buffer.
- Set the buffer to be exhausted.
- Make the next read to a mysql_file_seek() call to the required
offset.
TODO(cvicentiu, spetrunia) properly implement aligned seeks for
efficiency.
*/
cache->seek_not_done= 1;
cache->pos_in_file= needed_offset;
/* When reading it must appear as if we've started from the offset
that we've seeked here. We must let _my_b_cache_read assume that
by implying "no reading starting from pos_in_file" has happened. */
cache->read_pos= cache->buffer;
cache->read_end= cache->buffer;
}
} | O3 | c | seek_io_cache:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
movq 0x20(%rdi), %rax
movq %rsi, %rcx
subq %rdx, %rcx
jb 0x9530e
subq %rax, %rdx
addq 0x18(%rdi), %rdx
cmpq %rsi, %rdx
jbe 0x9530e
addq %rcx, %rax
movq %rax, 0x10(%rdi)
jmp 0x9532e
movq 0x8(%rdi), %rcx
cmpq %rsi, %rcx
cmovbq %rcx, %rsi
movl $0x1, 0xe0(%rdi)
movq %rsi, (%rdi)
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
popq %rbp
retq
| seek_io_cache:
push rbp
mov rbp, rsp
mov rdx, [rdi]
mov rax, [rdi+20h]
mov rcx, rsi
sub rcx, rdx
jb short loc_9530E
sub rdx, rax
add rdx, [rdi+18h]
cmp rdx, rsi
jbe short loc_9530E
add rax, rcx
mov [rdi+10h], rax
jmp short loc_9532E
loc_9530E:
mov rcx, [rdi+8]
cmp rcx, rsi
cmovb rsi, rcx
mov dword ptr [rdi+0E0h], 1
mov [rdi], rsi
mov [rdi+10h], rax
mov [rdi+18h], rax
loc_9532E:
pop rbp
retn
| long long seek_io_cache(long long a1, unsigned long long a2)
{
long long result; // rax
result = *(_QWORD *)(a1 + 32);
if ( a2 < *(_QWORD *)a1 || *(_QWORD *)(a1 + 24) + *(_QWORD *)a1 - result <= a2 )
{
if ( *(_QWORD *)(a1 + 8) < a2 )
a2 = *(_QWORD *)(a1 + 8);
*(_DWORD *)(a1 + 224) = 1;
*(_QWORD *)a1 = a2;
*(_QWORD *)(a1 + 16) = result;
*(_QWORD *)(a1 + 24) = result;
}
else
{
result += a2 - *(_QWORD *)a1;
*(_QWORD *)(a1 + 16) = result;
}
return result;
}
| seek_io_cache:
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x20]
MOV RCX,RSI
SUB RCX,RDX
JC 0x0019530e
SUB RDX,RAX
ADD RDX,qword ptr [RDI + 0x18]
CMP RDX,RSI
JBE 0x0019530e
ADD RAX,RCX
MOV qword ptr [RDI + 0x10],RAX
JMP 0x0019532e
LAB_0019530e:
MOV RCX,qword ptr [RDI + 0x8]
CMP RCX,RSI
CMOVC RSI,RCX
MOV dword ptr [RDI + 0xe0],0x1
MOV qword ptr [RDI],RSI
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],RAX
LAB_0019532e:
POP RBP
RET
|
void seek_io_cache(ulong *param_1,ulong param_2)
{
ulong uVar1;
ulong uVar2;
uVar1 = *param_1;
uVar2 = param_1[4];
if ((param_2 < uVar1) || ((uVar1 - uVar2) + param_1[3] <= param_2)) {
if (param_1[1] < param_2) {
param_2 = param_1[1];
}
*(int4 *)(param_1 + 0x1c) = 1;
*param_1 = param_2;
param_1[2] = uVar2;
param_1[3] = uVar2;
}
else {
param_1[2] = uVar2 + (param_2 - uVar1);
}
return;
}
| |
51,279 | inline_mysql_cond_init | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_cond_init(
#ifdef HAVE_PSI_COND_INTERFACE
PSI_cond_key key,
#endif
mysql_cond_t *that,
const pthread_condattr_t *attr)
{
#ifdef HAVE_PSI_COND_INTERFACE
that->m_psi= PSI_COND_CALL(init_cond)(key, &that->m_cond);
#else
that->m_psi= NULL;
#endif
return pthread_cond_init(&that->m_cond, attr);
} | O0 | c | inline_mysql_cond_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1af3fe(%rip), %rax # 0x1e3e98
movq (%rax), %rax
movq 0x60(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x253c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| inline_mysql_cond_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+60h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+30h], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_cond_init
add rsp, 20h
pop rbp
retn
| long long inline_mysql_cond_init(unsigned int a1, long long a2, long long a3)
{
*(_QWORD *)(a2 + 48) = (*((long long ( **)(_QWORD, long long))PSI_server + 12))(a1, a2);
return pthread_cond_init(a2, a3);
}
| inline_mysql_cond_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[0x2e3e98]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x60]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001253c0
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_cond_init(int4 param_1,pthread_cond_t *param_2,pthread_condattr_t *param_3)
{
longlong lVar1;
lVar1 = (**(code **)(PSI_server + 0x60))(param_1,param_2);
param_2[1].__align = lVar1;
pthread_cond_init(param_2,param_3);
return;
}
| |
51,280 | ggml_view_3d | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | struct ggml_tensor * ggml_view_3d(
struct ggml_context * ctx,
struct ggml_tensor * a,
int64_t ne0,
int64_t ne1,
int64_t ne2,
size_t nb1,
size_t nb2,
size_t offset) {
const int64_t ne[3] = { ne0, ne1, ne2 };
struct ggml_tensor * result = ggml_view_impl(ctx, a, 3, ne, offset);
result->nb[1] = nb1;
result->nb[2] = nb2;
result->nb[3] = result->nb[2]*ne2;
return result;
} | O1 | c | ggml_view_3d:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %r9, %rbx
movq %r8, %r14
movq 0x40(%rsp), %r15
movq 0x48(%rsp), %r8
movq %rsp, %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %r14, 0x10(%rax)
movl $0x3, %edx
movq %rax, %rcx
callq 0x931a3
movq %rbx, 0x38(%rax)
movq %r15, 0x40(%rax)
imulq %r14, %r15
movq %r15, 0x48(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
| ggml_view_3d:
push r15
push r14
push rbx
sub rsp, 20h
mov rbx, r9
mov r14, r8
mov r15, [rsp+38h+arg_0]
mov r8, [rsp+38h+arg_8]
mov rax, rsp
mov [rax], rdx
mov [rax+8], rcx
mov [rax+10h], r14
mov edx, 3
mov rcx, rax
call ggml_view_impl
mov [rax+38h], rbx
mov [rax+40h], r15
imul r15, r14
mov [rax+48h], r15
add rsp, 20h
pop rbx
pop r14
pop r15
retn
| _QWORD * ggml_view_3d(
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,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15,
long long a16)
{
_QWORD *result; // rax
_QWORD v19[7]; // [rsp+0h] [rbp-38h] BYREF
v19[0] = a3;
v19[1] = a4;
v19[2] = a5;
result = (_QWORD *)ggml_view_impl(a1, a2, 3, v19, a16, a7, a8, a9, a10, a11, a12, a13, a14);
result[7] = a6;
result[8] = a15;
result[9] = a5 * a15;
return result;
}
| |||
51,281 | ggml_view_3d | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | struct ggml_tensor * ggml_view_3d(
struct ggml_context * ctx,
struct ggml_tensor * a,
int64_t ne0,
int64_t ne1,
int64_t ne2,
size_t nb1,
size_t nb2,
size_t offset) {
const int64_t ne[3] = { ne0, ne1, ne2 };
struct ggml_tensor * result = ggml_view_impl(ctx, a, 3, ne, offset);
result->nb[1] = nb1;
result->nb[2] = nb2;
result->nb[3] = result->nb[2]*ne2;
return result;
} | O2 | c | ggml_view_3d:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %r9, %rbx
movq %r8, %r14
movq 0x40(%rsp), %r15
movq 0x48(%rsp), %r8
movq %rsp, %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %r14, 0x10(%rax)
pushq $0x3
popq %rdx
movq %rax, %rcx
callq 0x6c0ec
movq %rbx, 0x38(%rax)
movq %r15, 0x40(%rax)
imulq %r14, %r15
movq %r15, 0x48(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
| ggml_view_3d:
push r15
push r14
push rbx
sub rsp, 20h
mov rbx, r9
mov r14, r8
mov r15, [rsp+38h+arg_0]
mov r8, [rsp+38h+arg_8]
mov rax, rsp
mov [rax], rdx
mov [rax+8], rcx
mov [rax+10h], r14
push 3
pop rdx
mov rcx, rax
call ggml_view_impl
mov [rax+38h], rbx
mov [rax+40h], r15
imul r15, r14
mov [rax+48h], r15
add rsp, 20h
pop rbx
pop r14
pop r15
retn
| _QWORD * ggml_view_3d(
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,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15,
long long a16)
{
_QWORD *result; // rax
_QWORD v19[7]; // [rsp+0h] [rbp-38h] BYREF
v19[0] = a3;
v19[1] = a4;
v19[2] = a5;
result = (_QWORD *)ggml_view_impl(a1, a2, 3u, v19, a16, a7, a8, a9, a10, a11, a12, a13, a14);
result[7] = a6;
result[8] = a15;
result[9] = a5 * a15;
return result;
}
| ggml_view_3d:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RBX,R9
MOV R14,R8
MOV R15,qword ptr [RSP + 0x40]
MOV R8,qword ptr [RSP + 0x48]
MOV RAX,RSP
MOV qword ptr [RAX],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RAX + 0x10],R14
PUSH 0x3
POP RDX
MOV RCX,RAX
CALL 0x0016c0ec
MOV qword ptr [RAX + 0x38],RBX
MOV qword ptr [RAX + 0x40],R15
IMUL R15,R14
MOV qword ptr [RAX + 0x48],R15
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
void ggml_view_3d(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
long param_5,int8 param_6,long param_7,int8 param_8)
{
long lVar1;
int8 local_38;
int8 local_30;
long local_28;
local_38 = param_3;
local_30 = param_4;
local_28 = param_5;
lVar1 = ggml_view_impl(param_1,param_2,3,&local_38,param_8);
*(int8 *)(lVar1 + 0x38) = param_6;
*(long *)(lVar1 + 0x40) = param_7;
*(long *)(lVar1 + 0x48) = param_7 * param_5;
return;
}
| |
51,282 | ggml_view_3d | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | struct ggml_tensor * ggml_view_3d(
struct ggml_context * ctx,
struct ggml_tensor * a,
int64_t ne0,
int64_t ne1,
int64_t ne2,
size_t nb1,
size_t nb2,
size_t offset) {
const int64_t ne[3] = { ne0, ne1, ne2 };
struct ggml_tensor * result = ggml_view_impl(ctx, a, 3, ne, offset);
result->nb[1] = nb1;
result->nb[2] = nb2;
result->nb[3] = result->nb[2]*ne2;
return result;
} | O3 | c | ggml_view_3d:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %r9, %rbx
movq %r8, %r14
movq 0x40(%rsp), %r15
movq 0x48(%rsp), %r8
movq %rsp, %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %r14, 0x10(%rax)
movl $0x3, %edx
movq %rax, %rcx
callq 0x9200f
movq %rbx, 0x38(%rax)
movq %r15, 0x40(%rax)
imulq %r14, %r15
movq %r15, 0x48(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
| ggml_view_3d:
push r15
push r14
push rbx
sub rsp, 20h
mov rbx, r9
mov r14, r8
mov r15, [rsp+38h+arg_0]
mov r8, [rsp+38h+arg_8]
mov rax, rsp
mov [rax], rdx
mov [rax+8], rcx
mov [rax+10h], r14
mov edx, 3
mov rcx, rax
call ggml_view_impl
mov [rax+38h], rbx
mov [rax+40h], r15
imul r15, r14
mov [rax+48h], r15
add rsp, 20h
pop rbx
pop r14
pop r15
retn
| _QWORD * ggml_view_3d(
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,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15,
long long a16)
{
_QWORD *result; // rax
_QWORD v19[7]; // [rsp+0h] [rbp-38h] BYREF
v19[0] = a3;
v19[1] = a4;
v19[2] = a5;
result = (_QWORD *)ggml_view_impl(a1, a2, 3, v19, a16, a7, a8, a9, a10, a11, a12, a13, a14);
result[7] = a6;
result[8] = a15;
result[9] = a5 * a15;
return result;
}
| |||
51,283 | LefDefParser::defiNet::polyRouteStatusShieldName(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNet.cpp | const char* defiNet::polyRouteStatusShieldName(int index) const {
char errMsg[128];
if (index < 0 || index > numPolys_) {
sprintf (errMsg, "ERROR (DEFPARS-6085): The index number %d specified for the NET POLYGON is invalid.\nValid index is from 0 to %d. Specify a valid index number and then try again.",
index, numPolys_);
defiError(0, 6085, errMsg, defData);
return 0;
}
return polyRouteStatusShieldNames_[index];
} | O0 | cpp | LefDefParser::defiNet::polyRouteStatusShieldName(int) const:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movl %esi, 0x94(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x94(%rsp)
jl 0x3ec21
movq 0x8(%rsp), %rcx
movl 0x94(%rsp), %eax
cmpl 0x170(%rcx), %eax
jle 0x3ec71
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdi
movl 0x94(%rsp), %edx
movl 0x170(%rax), %ecx
leaq 0x3671a(%rip), %rsi # 0x75359
movb $0x0, %al
callq 0x7060
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq 0x240(%rax), %rcx
xorl %edi, %edi
movl $0x17c5, %esi # imm = 0x17C5
callq 0x2a600
movq $0x0, 0xa0(%rsp)
jmp 0x3ec91
movq 0x8(%rsp), %rax
movq 0x1a8(%rax), %rax
movslq 0x94(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZNK12LefDefParser7defiNet25polyRouteStatusShieldNameEi:
sub rsp, 0A8h
mov [rsp+0A8h+var_10], rdi
mov [rsp+0A8h+var_14], esi
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_A0], rax
cmp [rsp+0A8h+var_14], 0
jl short loc_3EC21
mov rcx, [rsp+0A8h+var_A0]
mov eax, [rsp+0A8h+var_14]
cmp eax, [rcx+170h]
jle short loc_3EC71
loc_3EC21:
mov rax, [rsp+0A8h+var_A0]
lea rdi, [rsp+0A8h+var_98]
mov edx, [rsp+0A8h+var_14]
mov ecx, [rax+170h]
lea rsi, aErrorDefpars60_6; "ERROR (DEFPARS-6085): The index number "...
mov al, 0
call _sprintf
mov rax, [rsp+0A8h+var_A0]
lea rdx, [rsp+0A8h+var_98]; int
mov rcx, [rax+240h]; char *
xor edi, edi; this
mov esi, 17C5h; int
call _ZN12LefDefParser9defiErrorEiiPKcPNS_8defrDataE; LefDefParser::defiError(int,int,char const*,LefDefParser::defrData *)
mov [rsp+0A8h+var_8], 0
jmp short loc_3EC91
loc_3EC71:
mov rax, [rsp+0A8h+var_A0]
mov rax, [rax+1A8h]
movsxd rcx, [rsp+0A8h+var_14]
mov rax, [rax+rcx*8]
mov [rsp+0A8h+var_8], rax
loc_3EC91:
mov rax, [rsp+0A8h+var_8]
add rsp, 0A8h
retn
| long long LefDefParser::defiNet::polyRouteStatusShieldName(LefDefParser::defrData **this, int a2)
{
LefDefParser::defrData *v2; // r8
char v4[132]; // [rsp+10h] [rbp-98h] BYREF
int v5; // [rsp+94h] [rbp-14h]
LefDefParser::defiNet *v6; // [rsp+98h] [rbp-10h]
v6 = (LefDefParser::defiNet *)this;
v5 = a2;
if ( a2 >= 0 && v5 <= *((_DWORD *)this + 92) )
return *((_QWORD *)this[53] + v5);
sprintf(
v4,
"ERROR (DEFPARS-6085): The index number %d specified for the NET POLYGON is invalid.\n"
"Valid index is from 0 to %d. Specify a valid index number and then try again.",
v5,
*((_DWORD *)this + 92));
LefDefParser::defiError(0LL, 6085, v4, this[72], v2);
return 0LL;
}
| polyRouteStatusShieldName:
SUB RSP,0xa8
MOV qword ptr [RSP + 0x98],RDI
MOV dword ptr [RSP + 0x94],ESI
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x8],RAX
CMP dword ptr [RSP + 0x94],0x0
JL 0x0013ec21
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0x94]
CMP EAX,dword ptr [RCX + 0x170]
JLE 0x0013ec71
LAB_0013ec21:
MOV RAX,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x10]
MOV EDX,dword ptr [RSP + 0x94]
MOV ECX,dword ptr [RAX + 0x170]
LEA RSI,[0x175359]
MOV AL,0x0
CALL 0x00107060
MOV RAX,qword ptr [RSP + 0x8]
LEA RDX,[RSP + 0x10]
MOV RCX,qword ptr [RAX + 0x240]
XOR EDI,EDI
MOV ESI,0x17c5
CALL 0x0012a600
MOV qword ptr [RSP + 0xa0],0x0
JMP 0x0013ec91
LAB_0013ec71:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x1a8]
MOVSXD RCX,dword ptr [RSP + 0x94]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0xa0],RAX
LAB_0013ec91:
MOV RAX,qword ptr [RSP + 0xa0]
ADD RSP,0xa8
RET
|
/* LefDefParser::defiNet::polyRouteStatusShieldName(int) const */
int8 __thiscall LefDefParser::defiNet::polyRouteStatusShieldName(defiNet *this,int param_1)
{
char local_98 [132];
int local_14;
defiNet *local_10;
int8 local_8;
if ((param_1 < 0) || (*(int *)(this + 0x170) < param_1)) {
local_14 = param_1;
local_10 = this;
sprintf(local_98,
"ERROR (DEFPARS-6085): The index number %d specified for the NET POLYGON is invalid.\nValid index is from 0 to %d. Specify a valid index number and then try again."
,(ulong)(uint)param_1,(ulong)*(uint *)(this + 0x170));
defiError(0,0x17c5,local_98,*(defrData **)(this + 0x240));
local_8 = 0;
}
else {
local_8 = *(int8 *)(*(long *)(this + 0x1a8) + (long)param_1 * 8);
}
return local_8;
}
| |
51,284 | LefDefParser::defiNet::polyRouteStatusShieldName(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNet.cpp | const char* defiNet::polyRouteStatusShieldName(int index) const {
char errMsg[128];
if (index < 0 || index > numPolys_) {
sprintf (errMsg, "ERROR (DEFPARS-6085): The index number %d specified for the NET POLYGON is invalid.\nValid index is from 0 to %d. Specify a valid index number and then try again.",
index, numPolys_);
defiError(0, 6085, errMsg, defData);
return 0;
}
return polyRouteStatusShieldNames_[index];
} | O3 | cpp | LefDefParser::defiNet::polyRouteStatusShieldName(int) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %esi, %edx
movq %rdi, %rbx
testl %esi, %esi
sets %al
movl 0x170(%rdi), %ecx
cmpl %esi, %ecx
setl %sil
orb %al, %sil
cmpb $0x1, %sil
jne 0x26808
leaq 0x1e9ab(%rip), %rsi # 0x4518b
xorl %r14d, %r14d
movq %rsp, %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x7060
movq 0x240(%rbx), %rcx
xorl %edi, %edi
movl $0x17c5, %esi # imm = 0x17C5
movq %r15, %rdx
callq 0x1bb18
jmp 0x26815
movq 0x1a8(%rbx), %rax
movl %edx, %ecx
movq (%rax,%rcx,8), %r14
movq %r14, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZNK12LefDefParser7defiNet25polyRouteStatusShieldNameEi:
push r15
push r14
push rbx
sub rsp, 80h
mov edx, esi
mov rbx, rdi
test esi, esi
sets al
mov ecx, [rdi+170h]
cmp ecx, esi
setl sil
or sil, al
cmp sil, 1
jnz short loc_26808
lea rsi, aErrorDefpars60_6; "ERROR (DEFPARS-6085): The index number "...
xor r14d, r14d
mov r15, rsp
mov rdi, r15
xor eax, eax
call _sprintf
mov rcx, [rbx+240h]; LefDefParser::defrData *
xor edi, edi; this
mov esi, 17C5h; int
mov rdx, r15; char *
call _ZN12LefDefParser9defiErrorEiiPKcPNS_8defrDataE; LefDefParser::defiError(int,int,char const*,LefDefParser::defrData *)
jmp short loc_26815
loc_26808:
mov rax, [rbx+1A8h]
mov ecx, edx
mov r14, [rax+rcx*8]
loc_26815:
mov rax, r14
add rsp, 80h
pop rbx
pop r14
pop r15
retn
| long long LefDefParser::defiNet::polyRouteStatusShieldName(LefDefParser::defiNet *this, int a2)
{
int v2; // ecx
long long v3; // r14
LefDefParser::defrData *v4; // r8
char v6[152]; // [rsp+0h] [rbp-98h] BYREF
v2 = *((_DWORD *)this + 92);
if ( a2 >= 0 && v2 >= a2 )
return *(_QWORD *)(*((_QWORD *)this + 53) + 8LL * (unsigned int)a2);
v3 = 0LL;
sprintf(
v6,
"ERROR (DEFPARS-6085): The index number %d specified for the NET POLYGON is invalid.\n"
"Valid index is from 0 to %d. Specify a valid index number and then try again.",
a2,
v2);
LefDefParser::defiError(0LL, 6085, v6, *((LefDefParser::defrData **)this + 72), v4);
return v3;
}
| polyRouteStatusShieldName:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x80
MOV EDX,ESI
MOV RBX,RDI
TEST ESI,ESI
SETS AL
MOV ECX,dword ptr [RDI + 0x170]
CMP ECX,ESI
SETL SIL
OR SIL,AL
CMP SIL,0x1
JNZ 0x00126808
LEA RSI,[0x14518b]
XOR R14D,R14D
MOV R15,RSP
MOV RDI,R15
XOR EAX,EAX
CALL 0x00107060
MOV RCX,qword ptr [RBX + 0x240]
XOR EDI,EDI
MOV ESI,0x17c5
MOV RDX,R15
CALL 0x0011bb18
JMP 0x00126815
LAB_00126808:
MOV RAX,qword ptr [RBX + 0x1a8]
MOV ECX,EDX
MOV R14,qword ptr [RAX + RCX*0x8]
LAB_00126815:
MOV RAX,R14
ADD RSP,0x80
POP RBX
POP R14
POP R15
RET
|
/* LefDefParser::defiNet::polyRouteStatusShieldName(int) const */
int8 __thiscall LefDefParser::defiNet::polyRouteStatusShieldName(defiNet *this,int param_1)
{
int8 uVar1;
char acStack_98 [128];
if (*(int *)(this + 0x170) < param_1 || param_1 < 0) {
uVar1 = 0;
sprintf(acStack_98,
"ERROR (DEFPARS-6085): The index number %d specified for the NET POLYGON is invalid.\nValid index is from 0 to %d. Specify a valid index number and then try again."
);
defiError(0,0x17c5,acStack_98,*(defrData **)(this + 0x240));
}
else {
uVar1 = *(int8 *)(*(long *)(this + 0x1a8) + (ulong)(uint)param_1 * 8);
}
return uVar1;
}
| |
51,285 | mysql_stmt_close_cont | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_close_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status)
{
MK_ASYNC_CONT_BODY(
stmt->mysql,
TRUE,
r_my_bool)
} | O3 | c | mysql_stmt_close_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %r15
cmpb $0x0, 0x15(%r15)
je 0x2cd4e
movb $0x1, 0x14(%r15)
movl %edx, 0x4(%r15)
leaq 0x38(%r15), %rdi
callq 0x2df73
movb $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x2cdb1
movl (%r15), %r15d
jmp 0x2ce27
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1dcc8(%rip), %rax # 0x4aa30
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 0x1dcad(%rip), %rax # 0x4aa40
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, (%rbx)
jmp 0x2ce27
movb $0x0, 0x15(%r15)
js 0x2cdbe
movb 0x8(%r15), %al
jmp 0x2ce22
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1dc54(%rip), %rax # 0x4aa30
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 0x1dc39(%rip), %rax # 0x4aa40
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, %al
movb %al, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mysql_stmt_close_cont:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
mov rcx, [rax+480h]
mov r15, [rcx+28h]
cmp byte ptr [r15+15h], 0
jz short loc_2CD4E
mov byte ptr [r15+14h], 1
mov [r15+4], edx
lea rdi, [r15+38h]
call my_context_continue
mov byte ptr [r15+14h], 0
test eax, eax
jle short loc_2CDB1
mov r15d, [r15]
jmp loc_2CE27
loc_2CD4E:
mov dword ptr [rax+90h], 7DEh
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+70h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov byte ptr [rbx], 1
jmp short loc_2CE27
loc_2CDB1:
mov byte ptr [r15+15h], 0
js short loc_2CDBE
mov al, [r15+8]
jmp short loc_2CE22
loc_2CDBE:
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 al, 1
loc_2CE22:
mov [rbx], al
xor r15d, r15d
loc_2CE27:
mov eax, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysql_stmt_close_cont(char *a1, long long a2, unsigned int a3)
{
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
unsigned int v6; // r15d
char v7; // al
v3 = *(_QWORD *)(a2 + 56);
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
if ( *((_BYTE *)v4 + 21) )
{
*((_BYTE *)v4 + 20) = 1;
v4[1] = a3;
v5 = my_context_continue(v4 + 14);
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
*((_BYTE *)v4 + 21) = 0;
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 = *((_BYTE *)v4 + 8);
}
*a1 = v7;
return 0;
}
else
{
return *v4;
}
}
else
{
*(_DWORD *)(v3 + 144) = 2014;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
v6 = 0;
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[14], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
*a1 = 1;
}
return v6;
}
| mysql_stmt_close_cont:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
MOV RCX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RCX + 0x28]
CMP byte ptr [R15 + 0x15],0x0
JZ 0x0012cd4e
MOV byte ptr [R15 + 0x14],0x1
MOV dword ptr [R15 + 0x4],EDX
LEA RDI,[R15 + 0x38]
CALL 0x0012df73
MOV byte ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0012cdb1
MOV R15D,dword ptr [R15]
JMP 0x0012ce27
LAB_0012cd4e:
MOV dword ptr [RAX + 0x90],0x7de
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x14aa30]
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,[0x14aa40]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV byte ptr [RBX],0x1
JMP 0x0012ce27
LAB_0012cdb1:
MOV byte ptr [R15 + 0x15],0x0
JS 0x0012cdbe
MOV AL,byte ptr [R15 + 0x8]
JMP 0x0012ce22
LAB_0012cdbe:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x14aa30]
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,[0x14aa40]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV AL,0x1
LAB_0012ce22:
MOV byte ptr [RBX],AL
XOR R15D,R15D
LAB_0012ce27:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_stmt_close_cont(int1 *param_1,long param_2,int4 param_3)
{
int4 *puVar1;
int1 uVar2;
int iVar3;
int4 uVar4;
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
if (*(char *)((long)puVar1 + 0x15) == '\0') {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7de;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
uVar4 = 0;
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),
PTR_s_Commands_out_of_sync__you_can_t_r_0014aab0,0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
*param_1 = 1;
}
else {
*(int1 *)(puVar1 + 5) = 1;
puVar1[1] = param_3;
iVar3 = my_context_continue(puVar1 + 0xe);
*(int1 *)(puVar1 + 5) = 0;
if (iVar3 < 1) {
*(int1 *)((long)puVar1 + 0x15) = 0;
if (iVar3 < 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_0014aa80,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar2 = 1;
}
else {
uVar2 = *(int1 *)(puVar1 + 2);
}
*param_1 = uVar2;
uVar4 = 0;
}
else {
uVar4 = *puVar1;
}
}
return uVar4;
}
| |
51,286 | my_wc_mb_filename | eloqsql/strings/ctype-utf8.c | static int
my_wc_mb_filename(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
static const char hex[]= "0123456789abcdef";
if (s >= e)
return MY_CS_TOOSMALL;
if (wc < 128 && filename_safe_char[wc])
{
*s= (uchar) wc;
return 1;
}
if (s + 3 > e)
return MY_CS_TOOSMALL3;
*s++= MY_FILENAME_ESCAPE;
if ((wc >= 0x00C0 && wc <= 0x05FF && (code= uni_0C00_05FF[wc - 0x00C0])) ||
(wc >= 0x1E00 && wc <= 0x1FFF && (code= uni_1E00_1FFF[wc - 0x1E00])) ||
(wc >= 0x2160 && wc <= 0x217F && (code= uni_2160_217F[wc - 0x2160])) ||
(wc >= 0x24B0 && wc <= 0x24EF && (code= uni_24B0_24EF[wc - 0x24B0])) ||
(wc >= 0xFF20 && wc <= 0xFF5F && (code= uni_FF20_FF5F[wc - 0xFF20])))
{
*s++= (code / 80) + 0x30;
*s++= (code % 80) + 0x30;
return 3;
}
/* Non letter */
if (s + 4 > e)
return MY_CS_TOOSMALL5;
*s++= hex[(wc >> 12) & 15];
*s++= hex[(wc >> 8) & 15];
*s++= hex[(wc >> 4) & 15];
*s++= hex[(wc) & 15];
return 5;
} | O0 | c | my_wc_mb_filename:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x68b0a
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x68d75
cmpq $0x80, -0x18(%rbp)
jae 0x68b40
movq -0x18(%rbp), %rcx
leaq 0x148781(%rip), %rax # 0x1b12a0
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x68b40
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x68d75
movq -0x20(%rbp), %rax
addq $0x3, %rax
cmpq -0x28(%rbp), %rax
jbe 0x68b5a
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0x68d75
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x40, (%rax)
cmpq $0xc0, -0x18(%rbp)
jb 0x68ba2
cmpq $0x5ff, -0x18(%rbp) # imm = 0x5FF
ja 0x68ba2
movq -0x18(%rbp), %rcx
subq $0xc0, %rcx
leaq 0x14b8ce(%rip), %rax # 0x1b4460
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x68c6e
cmpq $0x1e00, -0x18(%rbp) # imm = 0x1E00
jb 0x68bd8
cmpq $0x1fff, -0x18(%rbp) # imm = 0x1FFF
ja 0x68bd8
movq -0x18(%rbp), %rcx
subq $0x1e00, %rcx # imm = 0x1E00
leaq 0x31bf88(%rip), %rax # 0x384b50
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x68c6e
cmpq $0x2160, -0x18(%rbp) # imm = 0x2160
jb 0x68c0a
cmpq $0x217f, -0x18(%rbp) # imm = 0x217F
ja 0x68c0a
movq -0x18(%rbp), %rcx
subq $0x2160, %rcx # imm = 0x2160
leaq 0x14b722(%rip), %rax # 0x1b4320
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x68c6e
cmpq $0x24b0, -0x18(%rbp) # imm = 0x24B0
jb 0x68c3c
cmpq $0x24ef, -0x18(%rbp) # imm = 0x24EF
ja 0x68c3c
movq -0x18(%rbp), %rcx
subq $0x24b0, %rcx # imm = 0x24B0
leaq 0x14b730(%rip), %rax # 0x1b4360
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x68c6e
cmpq $0xff20, -0x18(%rbp) # imm = 0xFF20
jb 0x68cbc
cmpq $0xff5f, -0x18(%rbp) # imm = 0xFF5F
ja 0x68cbc
movq -0x18(%rbp), %rcx
subq $0xff20, %rcx # imm = 0xFF20
leaq 0x14b77e(%rip), %rax # 0x1b43e0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x68cbc
movl -0x2c(%rbp), %eax
movl $0x50, %ecx
cltd
idivl %ecx
addl $0x30, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
movl $0x50, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movb %dl, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x68d75
movq -0x20(%rbp), %rax
addq $0x4, %rax
cmpq -0x28(%rbp), %rax
jbe 0x68cd6
movl $0xffffff97, -0x4(%rbp) # imm = 0xFFFFFF97
jmp 0x68d75
movq -0x18(%rbp), %rcx
shrq $0xc, %rcx
andq $0xf, %rcx
leaq 0x14b617(%rip), %rax # 0x1b4300
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rcx
shrq $0x8, %rcx
andq $0xf, %rcx
leaq 0x14b5f0(%rip), %rax # 0x1b4300
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rcx
shrq $0x4, %rcx
andq $0xf, %rcx
leaq 0x14b5c9(%rip), %rax # 0x1b4300
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rcx
andq $0xf, %rcx
leaq 0x14b5a6(%rip), %rax # 0x1b4300
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| my_wc_mb_filename:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_68B0A
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_68D75
loc_68B0A:
cmp [rbp+var_18], 80h
jnb short loc_68B40
mov rcx, [rbp+var_18]
lea rax, filename_safe_char
movsx eax, byte ptr [rax+rcx]
cmp eax, 0
jz short loc_68B40
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp loc_68D75
loc_68B40:
mov rax, [rbp+var_20]
add rax, 3
cmp rax, [rbp+var_28]
jbe short loc_68B5A
mov [rbp+var_4], 0FFFFFF99h
jmp loc_68D75
loc_68B5A:
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 1
mov [rbp+var_20], rcx
mov byte ptr [rax], 40h ; '@'
cmp [rbp+var_18], 0C0h
jb short loc_68BA2
cmp [rbp+var_18], 5FFh
ja short loc_68BA2
mov rcx, [rbp+var_18]
sub rcx, 0C0h
lea rax, uni_0C00_05FF
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jnz loc_68C6E
loc_68BA2:
cmp [rbp+var_18], 1E00h
jb short loc_68BD8
cmp [rbp+var_18], 1FFFh
ja short loc_68BD8
mov rcx, [rbp+var_18]
sub rcx, 1E00h
lea rax, uni_1E00_1FFF
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jnz loc_68C6E
loc_68BD8:
cmp [rbp+var_18], 2160h
jb short loc_68C0A
cmp [rbp+var_18], 217Fh
ja short loc_68C0A
mov rcx, [rbp+var_18]
sub rcx, 2160h
lea rax, uni_2160_217F
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_68C6E
loc_68C0A:
cmp [rbp+var_18], 24B0h
jb short loc_68C3C
cmp [rbp+var_18], 24EFh
ja short loc_68C3C
mov rcx, [rbp+var_18]
sub rcx, 24B0h
lea rax, uni_24B0_24EF
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_68C6E
loc_68C3C:
cmp [rbp+var_18], 0FF20h
jb short loc_68CBC
cmp [rbp+var_18], 0FF5Fh
ja short loc_68CBC
mov rcx, [rbp+var_18]
sub rcx, 0FF20h
lea rax, uni_FF20_FF5F
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_68CBC
loc_68C6E:
mov eax, [rbp+var_2C]
mov ecx, 50h ; 'P'
cdq
idiv ecx
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov eax, [rbp+var_2C]
mov ecx, 50h ; 'P'
cdq
idiv ecx
add edx, 30h ; '0'
mov cl, dl
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov [rbp+var_4], 3
jmp loc_68D75
loc_68CBC:
mov rax, [rbp+var_20]
add rax, 4
cmp rax, [rbp+var_28]
jbe short loc_68CD6
mov [rbp+var_4], 0FFFFFF97h
jmp loc_68D75
loc_68CD6:
mov rcx, [rbp+var_18]
shr rcx, 0Ch
and rcx, 0Fh
lea rax, my_wc_mb_filename_hex; "0123456789abcdef"
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rcx, [rbp+var_18]
shr rcx, 8
and rcx, 0Fh
lea rax, my_wc_mb_filename_hex; "0123456789abcdef"
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rcx, [rbp+var_18]
shr rcx, 4
and rcx, 0Fh
lea rax, my_wc_mb_filename_hex; "0123456789abcdef"
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rcx, [rbp+var_18]
and rcx, 0Fh
lea rax, my_wc_mb_filename_hex; "0123456789abcdef"
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov [rbp+var_4], 5
loc_68D75:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_wc_mb_filename(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
int v5; // [rsp+0h] [rbp-2Ch]
_BYTE *v6; // [rsp+Ch] [rbp-20h]
if ( (unsigned long long)a3 < a4 )
{
if ( a2 < 0x80 && filename_safe_char[a2] )
{
*a3 = a2;
return 1;
}
else if ( (unsigned long long)(a3 + 3) <= a4 )
{
v6 = a3 + 1;
*a3 = 64;
if ( a2 >= 0xC0 && a2 <= 0x5FF && (v5 = uni_0C00_05FF[a2 - 192]) != 0
|| a2 >= 0x1E00 && a2 <= 0x1FFF && (v5 = uni_1E00_1FFF[a2 - 7680]) != 0
|| a2 >= 0x2160 && a2 <= 0x217F && (v5 = uni_2160_217F[a2 - 8544]) != 0
|| a2 >= 0x24B0 && a2 <= 0x24EF && (v5 = uni_24B0_24EF[a2 - 9392]) != 0
|| a2 >= 0xFF20 && a2 <= 0xFF5F && (v5 = uni_FF20_FF5F[a2 - 65312]) != 0 )
{
*v6 = v5 / 80 + 48;
a3[2] = v5 % 80 + 48;
return 3;
}
else if ( (unsigned long long)(a3 + 5) <= a4 )
{
*v6 = my_wc_mb_filename_hex[(unsigned __int16)a2 >> 12];
a3[2] = my_wc_mb_filename_hex[(a2 >> 8) & 0xF];
a3[3] = my_wc_mb_filename_hex[(unsigned __int8)a2 >> 4];
a3[4] = my_wc_mb_filename_hex[a2 & 0xF];
return 5;
}
else
{
return (unsigned int)-105;
}
}
else
{
return (unsigned int)-103;
}
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_filename:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x00168b0a
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00168d75
LAB_00168b0a:
CMP qword ptr [RBP + -0x18],0x80
JNC 0x00168b40
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x2b12a0]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x0
JZ 0x00168b40
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 0x00168d75
LAB_00168b40:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x00168b5a
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x00168d75
LAB_00168b5a:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x20],RCX
MOV byte ptr [RAX],0x40
CMP qword ptr [RBP + -0x18],0xc0
JC 0x00168ba2
CMP qword ptr [RBP + -0x18],0x5ff
JA 0x00168ba2
MOV RCX,qword ptr [RBP + -0x18]
SUB RCX,0xc0
LEA RAX,[0x2b4460]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x00168c6e
LAB_00168ba2:
CMP qword ptr [RBP + -0x18],0x1e00
JC 0x00168bd8
CMP qword ptr [RBP + -0x18],0x1fff
JA 0x00168bd8
MOV RCX,qword ptr [RBP + -0x18]
SUB RCX,0x1e00
LEA RAX,[0x484b50]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x00168c6e
LAB_00168bd8:
CMP qword ptr [RBP + -0x18],0x2160
JC 0x00168c0a
CMP qword ptr [RBP + -0x18],0x217f
JA 0x00168c0a
MOV RCX,qword ptr [RBP + -0x18]
SUB RCX,0x2160
LEA RAX,[0x2b4320]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x00168c6e
LAB_00168c0a:
CMP qword ptr [RBP + -0x18],0x24b0
JC 0x00168c3c
CMP qword ptr [RBP + -0x18],0x24ef
JA 0x00168c3c
MOV RCX,qword ptr [RBP + -0x18]
SUB RCX,0x24b0
LEA RAX,[0x2b4360]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x00168c6e
LAB_00168c3c:
CMP qword ptr [RBP + -0x18],0xff20
JC 0x00168cbc
CMP qword ptr [RBP + -0x18],0xff5f
JA 0x00168cbc
MOV RCX,qword ptr [RBP + -0x18]
SUB RCX,0xff20
LEA RAX,[0x2b43e0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x00168cbc
LAB_00168c6e:
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,0x50
CDQ
IDIV ECX
ADD EAX,0x30
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 EAX,dword ptr [RBP + -0x2c]
MOV ECX,0x50
CDQ
IDIV ECX
ADD EDX,0x30
MOV CL,DL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x3
JMP 0x00168d75
LAB_00168cbc:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x4
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x00168cd6
MOV dword ptr [RBP + -0x4],0xffffff97
JMP 0x00168d75
LAB_00168cd6:
MOV RCX,qword ptr [RBP + -0x18]
SHR RCX,0xc
AND RCX,0xf
LEA RAX,[0x2b4300]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x18]
SHR RCX,0x8
AND RCX,0xf
LEA RAX,[0x2b4300]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x18]
SHR RCX,0x4
AND RCX,0xf
LEA RAX,[0x2b4300]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x18]
AND RCX,0xf
LEA RAX,[0x2b4300]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x5
LAB_00168d75:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4
my_wc_mb_filename(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
uint local_34;
int4 local_c;
if (param_3 < param_4) {
if ((param_2 < 0x80) && (filename_safe_char[param_2] != '\0')) {
*param_3 = (char)param_2;
local_c = 1;
}
else if (param_4 < param_3 + 3) {
local_c = 0xffffff99;
}
else {
*param_3 = 0x40;
if ((((((param_2 < 0xc0) || (0x5ff < param_2)) ||
(local_34 = (uint)*(ushort *)(uni_0C00_05FF + (param_2 - 0xc0) * 2), local_34 == 0)) &&
(((param_2 < 0x1e00 || (0x1fff < param_2)) ||
(local_34 = (uint)*(ushort *)(uni_1E00_1FFF + (param_2 - 0x1e00) * 2), local_34 == 0))))
&& (((param_2 < 0x2160 || (0x217f < param_2)) ||
(local_34 = (uint)*(ushort *)(uni_2160_217F + (param_2 - 0x2160) * 2), local_34 == 0))
)) && ((((param_2 < 0x24b0 || (0x24ef < param_2)) ||
(local_34 = (uint)*(ushort *)(uni_24B0_24EF + (param_2 - 0x24b0) * 2),
local_34 == 0)) &&
(((param_2 < 0xff20 || (0xff5f < param_2)) ||
(local_34 = (uint)*(ushort *)(uni_FF20_FF5F + (param_2 - 0xff20) * 2),
local_34 == 0)))))) {
if (param_4 < param_3 + 5) {
local_c = 0xffffff97;
}
else {
param_3[1] = "0123456789abcdef"[param_2 >> 0xc & 0xf];
param_3[2] = "0123456789abcdef"[param_2 >> 8 & 0xf];
param_3[3] = "0123456789abcdef"[param_2 >> 4 & 0xf];
param_3[4] = "0123456789abcdef"[param_2 & 0xf];
local_c = 5;
}
}
else {
param_3[1] = (char)(local_34 / 0x50) + '0';
param_3[2] = (char)(local_34 % 0x50) + '0';
local_c = 3;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
51,287 | LefDefParser::lefiTiming::clear() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMacro.cpp | void
lefiTiming::clear()
{
numFrom_ = 0;
numTo_ = 0;
numOfAxisNumbers_ = 0;
numOfTableEntries_ = 0;
nowRise_ = 0;
hasTransition_ = 0;
hasDelay_ = 0;
hasFallSlew_ = 0;
hasFallSlew2_ = 0;
hasRiseSlew_ = 0;
hasRiseSlew2_ = 0;
hasRiseIntrinsic_ = 0;
hasFallIntrinsic_ = 0;
hasRiseSlew_ = 0;
hasFallSlew_ = 0;
hasRiseSlew2_ = 0;
hasFallSlew2_ = 0;
hasRiseRS_ = 0;
hasRiseCS_ = 0;
hasFallRS_ = 0;
hasFallCS_ = 0;
hasUnateness_ = 0;
hasFallAtt1_ = 0;
hasRiseAtt1_ = 0;
hasFallTo_ = 0;
hasRiseTo_ = 0;
hasStableTiming_ = 0;
hasSDFonePinTrigger_ = 0;
hasSDFtwoPinTrigger_ = 0;
hasSDFcondStart_ = 0;
hasSDFcondEnd_ = 0;
hasSDFcond_ = 0;
} | O3 | cpp | LefDefParser::lefiTiming::clear():
xorl %eax, %eax
movl %eax, (%rdi)
movl %eax, 0x14(%rdi)
movl %eax, 0x94(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rdi)
movups %xmm0, 0x34(%rdi)
movups %xmm0, 0x44(%rdi)
movups %xmm0, 0x54(%rdi)
movups %xmm0, 0x64(%rdi)
movups %xmm0, 0x74(%rdi)
movl %eax, 0x84(%rdi)
retq
nop
| _ZN12LefDefParser10lefiTiming5clearEv:
xor eax, eax
mov [rdi], eax
mov [rdi+14h], eax
mov [rdi+94h], eax
xorps xmm0, xmm0
movups xmmword ptr [rdi+24h], xmm0
movups xmmword ptr [rdi+34h], xmm0
movups xmmword ptr [rdi+44h], xmm0
movups xmmword ptr [rdi+54h], xmm0
movups xmmword ptr [rdi+64h], xmm0
movups xmmword ptr [rdi+74h], xmm0
mov [rdi+84h], eax
retn
| long long LefDefParser::lefiTiming::clear(LefDefParser::lefiTiming *this)
{
long long result; // rax
result = 0LL;
*(_DWORD *)this = 0;
*((_DWORD *)this + 5) = 0;
*((_DWORD *)this + 37) = 0;
*(_OWORD *)((char *)this + 36) = 0LL;
*(_OWORD *)((char *)this + 52) = 0LL;
*(_OWORD *)((char *)this + 68) = 0LL;
*(_OWORD *)((char *)this + 84) = 0LL;
*(_OWORD *)((char *)this + 100) = 0LL;
*(_OWORD *)((char *)this + 116) = 0LL;
*((_DWORD *)this + 33) = 0;
return result;
}
| clear:
XOR EAX,EAX
MOV dword ptr [RDI],EAX
MOV dword ptr [RDI + 0x14],EAX
MOV dword ptr [RDI + 0x94],EAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x24],XMM0
MOVUPS xmmword ptr [RDI + 0x34],XMM0
MOVUPS xmmword ptr [RDI + 0x44],XMM0
MOVUPS xmmword ptr [RDI + 0x54],XMM0
MOVUPS xmmword ptr [RDI + 0x64],XMM0
MOVUPS xmmword ptr [RDI + 0x74],XMM0
MOV dword ptr [RDI + 0x84],EAX
RET
|
/* LefDefParser::lefiTiming::clear() */
void __thiscall LefDefParser::lefiTiming::clear(lefiTiming *this)
{
*(int4 *)this = 0;
*(int4 *)(this + 0x14) = 0;
*(int4 *)(this + 0x94) = 0;
*(int8 *)(this + 0x24) = 0;
*(int8 *)(this + 0x2c) = 0;
*(int8 *)(this + 0x34) = 0;
*(int8 *)(this + 0x3c) = 0;
*(int8 *)(this + 0x44) = 0;
*(int8 *)(this + 0x4c) = 0;
*(int8 *)(this + 0x54) = 0;
*(int8 *)(this + 0x5c) = 0;
*(int8 *)(this + 100) = 0;
*(int8 *)(this + 0x6c) = 0;
*(int8 *)(this + 0x74) = 0;
*(int8 *)(this + 0x7c) = 0;
*(int4 *)(this + 0x84) = 0;
return;
}
| |
51,288 | inline_mysql_cond_init | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_cond_init(
#ifdef HAVE_PSI_COND_INTERFACE
PSI_cond_key key,
#endif
mysql_cond_t *that,
const pthread_condattr_t *attr)
{
#ifdef HAVE_PSI_COND_INTERFACE
that->m_psi= PSI_COND_CALL(init_cond)(key, &that->m_cond);
#else
that->m_psi= NULL;
#endif
return pthread_cond_init(&that->m_cond, attr);
} | O0 | c | inline_mysql_cond_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x265556(%rip), %rax # 0x2cb2a0
movq (%rax), %rax
movq 0x60(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a370
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| inline_mysql_cond_init_2:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+60h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+30h], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_cond_init
add rsp, 20h
pop rbp
retn
| long long inline_mysql_cond_init_2(unsigned int a1, long long a2, long long a3)
{
*(_QWORD *)(a2 + 48) = ((long long ( *)(_QWORD, long long))PSI_server[12])(a1, a2);
return pthread_cond_init(a2, a3);
}
| inline_mysql_cond_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[0x3cb2a0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x60]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a370
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_cond_init(int4 param_1,pthread_cond_t *param_2,pthread_condattr_t *param_3)
{
longlong lVar1;
lVar1 = (**(code **)(PSI_server + 0x60))(param_1,param_2);
param_2[1].__align = lVar1;
pthread_cond_init(param_2,param_3);
return;
}
| |
51,289 | string_process_escapes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | monkey531[P]llama/common/common.cpp | void string_process_escapes(std::string & input) {
std::size_t input_len = input.length();
std::size_t output_idx = 0;
for (std::size_t input_idx = 0; input_idx < input_len; ++input_idx) {
if (input[input_idx] == '\\' && input_idx + 1 < input_len) {
switch (input[++input_idx]) {
case 'n': input[output_idx++] = '\n'; break;
case 'r': input[output_idx++] = '\r'; break;
case 't': input[output_idx++] = '\t'; break;
case '\'': input[output_idx++] = '\''; break;
case '\"': input[output_idx++] = '\"'; break;
case '\\': input[output_idx++] = '\\'; break;
case 'x':
// Handle \x12, etc
if (input_idx + 2 < input_len) {
const char x[3] = { input[input_idx + 1], input[input_idx + 2], 0 };
char *err_p = nullptr;
const long val = std::strtol(x, &err_p, 16);
if (err_p == x + 2) {
input_idx += 2;
input[output_idx++] = char(val);
break;
}
}
// fall through
default: input[output_idx++] = '\\';
input[output_idx++] = input[input_idx]; break;
}
} else {
input[output_idx++] = input[input_idx];
}
}
input.resize(output_idx);
} | O1 | cpp | string_process_escapes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r13
testq %r13, %r13
je 0x7442c
leaq 0xf(%rsp), %rbp
xorl %r14d, %r14d
leaq 0xd(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %eax, %eax
movq (%rbx), %rcx
movb (%rcx,%rax), %dl
cmpb $0x5c, %dl
jne 0x74355
leaq 0x1(%rax), %r15
cmpq %r13, %r15
jae 0x74355
movzbl (%rcx,%r15), %edx
cmpl $0x6d, %edx
jle 0x74361
cmpl $0x73, %edx
jg 0x7437b
cmpl $0x6e, %edx
je 0x743cc
cmpl $0x72, %edx
jne 0x74403
movb $0xd, (%rcx,%r14)
jmp 0x743df
movb %dl, (%rcx,%r14)
incq %r14
jmp 0x7441e
cmpl $0x22, %edx
je 0x743c5
cmpl $0x27, %edx
je 0x743da
cmpl $0x5c, %edx
jne 0x74403
movb $0x5c, (%rcx,%r14)
jmp 0x743df
cmpl $0x74, %edx
je 0x743d3
cmpl $0x78, %edx
jne 0x74403
leaq 0x3(%rax), %r12
cmpq %r13, %r12
jae 0x74403
movb 0x2(%rcx,%rax), %dl
movb %dl, 0xd(%rsp)
movb 0x3(%rcx,%rax), %al
movb %al, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x10, %edx
callq 0x1bc60
movq 0x10(%rsp), %rcx
cmpq %rbp, %rcx
je 0x743e4
movq %r15, %r12
jmp 0x743f1
movb $0x22, (%rcx,%r14)
jmp 0x743df
movb $0xa, (%rcx,%r14)
jmp 0x743df
movb $0x9, (%rcx,%r14)
jmp 0x743df
movb $0x27, (%rcx,%r14)
incq %r14
jmp 0x7441b
movq (%rbx), %rdx
movb %al, (%rdx,%r14)
incq %r14
movq %r12, %r15
movq %r12, %rax
cmpq %rbp, %rcx
leaq 0xd(%rsp), %rdi
leaq 0x10(%rsp), %rsi
je 0x7441e
movq (%rbx), %rax
movb $0x5c, (%rax,%r14)
movq (%rbx), %rax
movb (%rax,%r15), %cl
movb %cl, 0x1(%rax,%r14)
addq $0x2, %r14
movq %r15, %rax
incq %rax
cmpq %r13, %rax
jb 0x74316
jmp 0x7442f
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1b260
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _Z22string_process_escapesRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov r13, [rdi+8]
test r13, r13
jz loc_7442C
lea rbp, [rsp+48h+var_39]
xor r14d, r14d
lea rdi, [rsp+48h+var_3B]
lea rsi, [rsp+48h+var_38]
xor eax, eax
loc_74316:
mov rcx, [rbx]
mov dl, [rcx+rax]
cmp dl, 5Ch ; '\'
jnz short loc_74355
lea r15, [rax+1]
cmp r15, r13
jnb short loc_74355
movzx edx, byte ptr [rcx+r15]
cmp edx, 6Dh ; 'm'
jle short loc_74361
cmp edx, 73h ; 's'
jg short loc_7437B
cmp edx, 6Eh ; 'n'
jz loc_743CC
cmp edx, 72h ; 'r'
jnz loc_74403
mov byte ptr [rcx+r14], 0Dh
jmp loc_743DF
loc_74355:
mov [rcx+r14], dl
inc r14
jmp loc_7441E
loc_74361:
cmp edx, 22h ; '"'
jz short loc_743C5
cmp edx, 27h ; '''
jz short loc_743DA
cmp edx, 5Ch ; '\'
jnz loc_74403
mov byte ptr [rcx+r14], 5Ch ; '\'
jmp short loc_743DF
loc_7437B:
cmp edx, 74h ; 't'
jz short loc_743D3
cmp edx, 78h ; 'x'
jnz short loc_74403
lea r12, [rax+3]
cmp r12, r13
jnb short loc_74403
mov dl, [rcx+rax+2]
mov [rsp+48h+var_3B], dl
mov al, [rcx+rax+3]
mov [rsp+48h+var_3A], al
mov [rsp+48h+var_39], 0
mov [rsp+48h+var_38], 0
mov edx, 10h
call _strtol
mov rcx, [rsp+48h+var_38]
cmp rcx, rbp
jz short loc_743E4
mov r12, r15
jmp short loc_743F1
loc_743C5:
mov byte ptr [rcx+r14], 22h ; '"'
jmp short loc_743DF
loc_743CC:
mov byte ptr [rcx+r14], 0Ah
jmp short loc_743DF
loc_743D3:
mov byte ptr [rcx+r14], 9
jmp short loc_743DF
loc_743DA:
mov byte ptr [rcx+r14], 27h ; '''
loc_743DF:
inc r14
jmp short loc_7441B
loc_743E4:
mov rdx, [rbx]
mov [rdx+r14], al
inc r14
mov r15, r12
loc_743F1:
mov rax, r12
cmp rcx, rbp
lea rdi, [rsp+48h+var_3B]
lea rsi, [rsp+48h+var_38]
jz short loc_7441E
loc_74403:
mov rax, [rbx]
mov byte ptr [rax+r14], 5Ch ; '\'
mov rax, [rbx]
mov cl, [rax+r15]
mov [rax+r14+1], cl
add r14, 2
loc_7441B:
mov rax, r15
loc_7441E:
inc rax
cmp rax, r13
jb loc_74316
jmp short loc_7442F
loc_7442C:
xor r14d, r14d
loc_7442F:
mov rdi, rbx
mov rsi, r14
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long string_process_escapes(long long *a1)
{
unsigned long long v1; // r13
long long v2; // r14
long long v3; // rax
long long v4; // rcx
char v5; // dl
long long v6; // r15
unsigned int v7; // edx
long long v8; // r12
char v9; // al
char *v10; // rcx
_BYTE v12[2]; // [rsp+Dh] [rbp-3Bh] BYREF
char v13; // [rsp+Fh] [rbp-39h] BYREF
char *v14; // [rsp+10h] [rbp-38h] BYREF
v1 = a1[1];
if ( v1 )
{
v2 = 0LL;
v3 = 0LL;
while ( 1 )
{
v4 = *a1;
v5 = *(_BYTE *)(*a1 + v3);
if ( v5 == 92 )
{
v6 = v3 + 1;
if ( v3 + 1 < v1 )
break;
}
*(_BYTE *)(v4 + v2++) = v5;
LABEL_29:
if ( ++v3 >= v1 )
return std::string::resize(a1, v2, 0LL);
}
v7 = *(unsigned __int8 *)(v4 + v6);
if ( v7 <= 0x6D )
{
switch ( v7 )
{
case '"':
*(_BYTE *)(v4 + v2) = 34;
goto LABEL_24;
case '\'':
*(_BYTE *)(v4 + v2) = 39;
goto LABEL_24;
case '\\':
*(_BYTE *)(v4 + v2) = 92;
goto LABEL_24;
}
}
else if ( *(unsigned __int8 *)(v4 + v6) > 0x73u )
{
if ( v7 == 116 )
{
*(_BYTE *)(v4 + v2) = 9;
goto LABEL_24;
}
if ( v7 == 120 )
{
v8 = v3 + 3;
if ( v3 + 3 < v1 )
{
v12[0] = *(_BYTE *)(v4 + v3 + 2);
v12[1] = *(_BYTE *)(v4 + v3 + 3);
v13 = 0;
v14 = 0LL;
v9 = strtol(v12, &v14, 16LL);
v10 = v14;
if ( v14 == &v13 )
{
*(_BYTE *)(*a1 + v2++) = v9;
v6 = v8;
}
else
{
v8 = v6;
}
v3 = v8;
if ( v10 == &v13 )
goto LABEL_29;
}
}
}
else
{
if ( v7 == 110 )
{
*(_BYTE *)(v4 + v2) = 10;
goto LABEL_24;
}
if ( v7 == 114 )
{
*(_BYTE *)(v4 + v2) = 13;
LABEL_24:
++v2;
LABEL_28:
v3 = v6;
goto LABEL_29;
}
}
*(_BYTE *)(*a1 + v2) = 92;
*(_BYTE *)(*a1 + v2 + 1) = *(_BYTE *)(*a1 + v6);
v2 += 2LL;
goto LABEL_28;
}
v2 = 0LL;
return std::string::resize(a1, v2, 0LL);
}
| string_process_escapes:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R13,qword ptr [RDI + 0x8]
TEST R13,R13
JZ 0x0017442c
LEA RBP,[RSP + 0xf]
XOR R14D,R14D
LEA RDI,[RSP + 0xd]
LEA RSI,[RSP + 0x10]
XOR EAX,EAX
LAB_00174316:
MOV RCX,qword ptr [RBX]
MOV DL,byte ptr [RCX + RAX*0x1]
CMP DL,0x5c
JNZ 0x00174355
LEA R15,[RAX + 0x1]
CMP R15,R13
JNC 0x00174355
MOVZX EDX,byte ptr [RCX + R15*0x1]
CMP EDX,0x6d
JLE 0x00174361
CMP EDX,0x73
JG 0x0017437b
CMP EDX,0x6e
JZ 0x001743cc
CMP EDX,0x72
JNZ 0x00174403
MOV byte ptr [RCX + R14*0x1],0xd
JMP 0x001743df
LAB_00174355:
MOV byte ptr [RCX + R14*0x1],DL
INC R14
JMP 0x0017441e
LAB_00174361:
CMP EDX,0x22
JZ 0x001743c5
CMP EDX,0x27
JZ 0x001743da
CMP EDX,0x5c
JNZ 0x00174403
MOV byte ptr [RCX + R14*0x1],0x5c
JMP 0x001743df
LAB_0017437b:
CMP EDX,0x74
JZ 0x001743d3
CMP EDX,0x78
JNZ 0x00174403
LEA R12,[RAX + 0x3]
CMP R12,R13
JNC 0x00174403
MOV DL,byte ptr [RCX + RAX*0x1 + 0x2]
MOV byte ptr [RSP + 0xd],DL
MOV AL,byte ptr [RCX + RAX*0x1 + 0x3]
MOV byte ptr [RSP + 0xe],AL
MOV byte ptr [RSP + 0xf],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV EDX,0x10
CALL 0x0011bc60
MOV RCX,qword ptr [RSP + 0x10]
CMP RCX,RBP
JZ 0x001743e4
MOV R12,R15
JMP 0x001743f1
LAB_001743c5:
MOV byte ptr [RCX + R14*0x1],0x22
JMP 0x001743df
LAB_001743cc:
MOV byte ptr [RCX + R14*0x1],0xa
JMP 0x001743df
LAB_001743d3:
MOV byte ptr [RCX + R14*0x1],0x9
JMP 0x001743df
LAB_001743da:
MOV byte ptr [RCX + R14*0x1],0x27
LAB_001743df:
INC R14
JMP 0x0017441b
LAB_001743e4:
MOV RDX,qword ptr [RBX]
MOV byte ptr [RDX + R14*0x1],AL
INC R14
MOV R15,R12
LAB_001743f1:
MOV RAX,R12
CMP RCX,RBP
LEA RDI,[RSP + 0xd]
LEA RSI,[RSP + 0x10]
JZ 0x0017441e
LAB_00174403:
MOV RAX,qword ptr [RBX]
MOV byte ptr [RAX + R14*0x1],0x5c
MOV RAX,qword ptr [RBX]
MOV CL,byte ptr [RAX + R15*0x1]
MOV byte ptr [RAX + R14*0x1 + 0x1],CL
ADD R14,0x2
LAB_0017441b:
MOV RAX,R15
LAB_0017441e:
INC RAX
CMP RAX,R13
JC 0x00174316
JMP 0x0017442f
LAB_0017442c:
XOR R14D,R14D
LAB_0017442f:
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x0011b260
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_process_escapes(std::__cxx11::string&) */
void string_process_escapes(string *param_1)
{
byte bVar1;
ulong uVar2;
long lVar3;
ulong uVar4;
long lVar6;
char local_3b;
int1 local_3a;
char local_39;
char *local_38;
ulong uVar5;
uVar2 = *(ulong *)(param_1 + 8);
if (uVar2 == 0) {
lVar6 = 0;
}
else {
lVar6 = 0;
uVar4 = 0;
do {
lVar3 = *(long *)param_1;
if ((*(char *)(lVar3 + uVar4) == '\\') && (uVar5 = uVar4 + 1, uVar5 < uVar2)) {
bVar1 = *(byte *)(lVar3 + uVar5);
if (bVar1 < 0x6e) {
if (bVar1 == 0x22) {
*(int1 *)(lVar3 + lVar6) = 0x22;
}
else if (bVar1 == 0x27) {
*(int1 *)(lVar3 + lVar6) = 0x27;
}
else {
if (bVar1 != 0x5c) goto LAB_00174403;
*(int1 *)(lVar3 + lVar6) = 0x5c;
}
}
else if (bVar1 < 0x74) {
if (bVar1 == 0x6e) {
*(int1 *)(lVar3 + lVar6) = 10;
}
else {
if (bVar1 != 0x72) goto LAB_00174403;
*(int1 *)(lVar3 + lVar6) = 0xd;
}
}
else {
if (bVar1 != 0x74) {
if ((bVar1 == 0x78) && (uVar4 + 3 < uVar2)) {
local_3b = *(char *)(lVar3 + 2 + uVar4);
local_3a = *(int1 *)(lVar3 + 3 + uVar4);
local_39 = '\0';
local_38 = (char *)0x0;
lVar3 = strtol(&local_3b,&local_38,0x10);
if (local_38 == &local_39) {
*(char *)(*(long *)param_1 + lVar6) = (char)lVar3;
lVar6 = lVar6 + 1;
uVar5 = uVar4 + 3;
goto LAB_0017441e;
}
}
LAB_00174403:
*(int1 *)(*(long *)param_1 + lVar6) = 0x5c;
*(int1 *)(*(long *)param_1 + 1 + lVar6) =
*(int1 *)(*(long *)param_1 + uVar5);
lVar6 = lVar6 + 2;
goto LAB_0017441e;
}
*(int1 *)(lVar3 + lVar6) = 9;
}
lVar6 = lVar6 + 1;
}
else {
*(char *)(lVar3 + lVar6) = *(char *)(lVar3 + uVar4);
lVar6 = lVar6 + 1;
uVar5 = uVar4;
}
LAB_0017441e:
uVar4 = uVar5 + 1;
} while (uVar4 < uVar2);
}
std::__cxx11::string::resize((ulong)param_1,(char)lVar6);
return;
}
| |
51,290 | bitmap_get_first_set | eloqsql/mysys/my_bitmap.c | uint bitmap_get_first_set(const MY_BITMAP *map)
{
uint i;
my_bitmap_map *data_ptr= map->bitmap, *end= map->last_word_ptr;
DBUG_ASSERT(map->bitmap);
for (i=0; data_ptr < end; data_ptr++, i++)
if (*data_ptr)
goto found;
if (!(*data_ptr & ~map->last_word_mask))
return MY_BIT_NONE;
found:
return get_first_set(*data_ptr, i);
} | O0 | c | bitmap_get_first_set:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xf2005
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xf203a
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xf2021
jmp 0xf205c
jmp 0xf2023
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf200c
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0xf205a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf206d
jmp 0xf205c
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl -0x14(%rbp), %esi
callq 0xf2080
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| bitmap_get_first_set:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_28], rax
jmp short $+2
loc_F2005:
mov [rbp+var_14], 0
loc_F200C:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jnb short loc_F203A
mov rax, [rbp+var_20]
cmp dword ptr [rax], 0
jz short loc_F2021
jmp short loc_F205C
loc_F2021:
jmp short $+2
loc_F2023:
mov rax, [rbp+var_20]
add rax, 4
mov [rbp+var_20], rax
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_F200C
loc_F203A:
mov rax, [rbp+var_20]
mov eax, [rax]
mov rcx, [rbp+var_10]
mov ecx, [rcx+18h]
xor ecx, 0FFFFFFFFh
and eax, ecx
cmp eax, 0
jnz short loc_F205A
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_F206D
loc_F205A:
jmp short $+2
loc_F205C:
mov rax, [rbp+var_20]
mov edi, [rax]
mov esi, [rbp+var_14]
call get_first_set
mov [rbp+var_4], eax
loc_F206D:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long bitmap_get_first_set(long long a1)
{
_DWORD *v2; // [rsp+10h] [rbp-20h]
unsigned int v3; // [rsp+1Ch] [rbp-14h]
v2 = *(_DWORD **)a1;
v3 = 0;
while ( (unsigned long long)v2 < *(_QWORD *)(a1 + 8) )
{
if ( *v2 )
return (unsigned int)get_first_set((unsigned int)*v2, v3);
++v2;
++v3;
}
if ( (~*(_DWORD *)(a1 + 24) & *v2) == 0 )
return (unsigned int)-1;
return (unsigned int)get_first_set((unsigned int)*v2, v3);
}
| bitmap_get_first_set:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001f2005
LAB_001f2005:
MOV dword ptr [RBP + -0x14],0x0
LAB_001f200c:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x001f203a
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX],0x0
JZ 0x001f2021
JMP 0x001f205c
LAB_001f2021:
JMP 0x001f2023
LAB_001f2023:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x4
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001f200c
LAB_001f203a:
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x18]
XOR ECX,0xffffffff
AND EAX,ECX
CMP EAX,0x0
JNZ 0x001f205a
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001f206d
LAB_001f205a:
JMP 0x001f205c
LAB_001f205c:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x001f2080
MOV dword ptr [RBP + -0x4],EAX
LAB_001f206d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 bitmap_get_first_set(int8 *param_1)
{
uint *local_28;
int local_1c;
int4 local_c;
local_28 = (uint *)*param_1;
local_1c = 0;
for (; local_28 < (uint *)param_1[1]; local_28 = local_28 + 1) {
if (*local_28 != 0) goto LAB_001f205c;
local_1c = local_1c + 1;
}
if ((*local_28 & (*(uint *)(param_1 + 3) ^ 0xffffffff)) == 0) {
local_c = 0xffffffff;
}
else {
LAB_001f205c:
local_c = get_first_set(*local_28,local_1c);
}
return local_c;
}
| |
51,291 | my_load_path | eloqsql/mysys/mf_loadpath.c | char * my_load_path(char * to, const char *path,
const char *own_path_prefix)
{
char buff[FN_REFLEN+1];
const char *from= buff;
int is_cur;
DBUG_ENTER("my_load_path");
DBUG_PRINT("enter",("path: %s prefix: %s",path,
own_path_prefix ? own_path_prefix : ""));
if ((path[0] == FN_HOMELIB && path[1] == FN_LIBCHAR) ||
test_if_hard_path(path))
from= path;
else if ((is_cur=(path[0] == FN_CURLIB && path[1] == FN_LIBCHAR)) ||
(is_prefix(path,FN_PARENTDIR)) ||
! own_path_prefix)
{
if (is_cur)
is_cur=2; /* Remove current dir */
if (! my_getwd(buff,(uint) (FN_REFLEN-strlen(path)+is_cur),MYF(0)))
{
size_t length= strlen(buff);
(void) strmake(buff + length, path+is_cur, FN_REFLEN - length);
}
else
from= path; /* Return org file name */
}
else
(void) strxnmov(buff, FN_REFLEN, own_path_prefix, path, NullS);
strmake(to, from, FN_REFLEN-1);
DBUG_PRINT("exit",("to: %s",to));
DBUG_RETURN(to);
} | O3 | c | my_load_path:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpb $0x7e, (%rsi)
jne 0x4010a
cmpb $0x2f, 0x1(%r14)
je 0x40116
movq %r14, %rdi
callq 0x3e44e
testl %eax, %eax
je 0x40151
movq %r14, %r12
movl $0x1ff, %edx # imm = 0x1FF
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6cfe0
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x401f8
movq %rbx, %rax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x2e, (%r14)
jne 0x40164
movl $0x2, %r13d
cmpb $0x2f, 0x1(%r14)
je 0x401a3
leaq 0x4abed(%rip), %rsi # 0x8ad58
movq %r14, %rdi
callq 0x6b6a4
xorl %r13d, %r13d
testq %r15, %r15
je 0x401a3
testl %eax, %eax
jne 0x401a3
leaq -0x240(%rbp), %r12
movl $0x200, %esi # imm = 0x200
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x6d100
jmp 0x40119
movq %r14, %rdi
callq 0x33130
leal 0x200(%r13), %esi
subl %eax, %esi
leaq -0x240(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x3e2b8
testl %eax, %eax
jne 0x40116
movq %r12, %rdi
callq 0x33130
leaq (%rax,%rbp), %rdi
addq $-0x240, %rdi # imm = 0xFDC0
addq %r13, %r14
movl $0x200, %edx # imm = 0x200
subq %rax, %rdx
movq %r14, %rsi
callq 0x6cfe0
jmp 0x40119
callq 0x33370
nopl (%rax)
| my_load_path:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 218h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp byte ptr [rsi], 7Eh ; '~'
jnz short loc_4010A
cmp byte ptr [r14+1], 2Fh ; '/'
jz short loc_40116
loc_4010A:
mov rdi, r14
call test_if_hard_path
test eax, eax
jz short loc_40151
loc_40116:
mov r12, r14
loc_40119:
mov edx, 1FFh
mov rdi, rbx
mov rsi, r12
call strmake
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_401F8
mov rax, rbx
add rsp, 218h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_40151:
cmp byte ptr [r14], 2Eh ; '.'
jnz short loc_40164
mov r13d, 2
cmp byte ptr [r14+1], 2Fh ; '/'
jz short loc_401A3
loc_40164:
lea rsi, asc_8AD58; ".."
mov rdi, r14
call is_prefix
xor r13d, r13d
test r15, r15
jz short loc_401A3
test eax, eax
jnz short loc_401A3
lea r12, [rbp+var_240]
mov esi, 200h
mov rdi, r12
mov rdx, r15
mov rcx, r14
xor r8d, r8d
xor eax, eax
call strxnmov
jmp loc_40119
loc_401A3:
mov rdi, r14
call _strlen
lea esi, [r13+200h]
sub esi, eax
lea r12, [rbp+var_240]
mov rdi, r12
xor edx, edx
call my_getwd
test eax, eax
jnz loc_40116
mov rdi, r12
call _strlen
lea rdi, [rax+rbp]
add rdi, 0FFFFFFFFFFFFFDC0h
add r14, r13
mov edx, 200h
sub rdx, rax
mov rsi, r14
call strmake
jmp loc_40119
loc_401F8:
call ___stack_chk_fail
| long long my_load_path(long long a1, char *a2, long long a3)
{
char *v4; // r12
long long v6; // r13
int v7; // eax
int v8; // r9d
int v9; // eax
long long v10; // rax
char v11[528]; // [rsp+0h] [rbp-240h] BYREF
unsigned long long v12; // [rsp+210h] [rbp-30h]
v12 = __readfsqword(0x28u);
if ( (*a2 != 126 || a2[1] != 47) && !test_if_hard_path(a2) )
{
if ( *a2 != 46 || (v6 = 2LL, a2[1] != 47) )
{
v7 = is_prefix(a2, "..");
v6 = 0LL;
if ( a3 )
{
if ( !v7 )
{
v4 = v11;
strxnmov((unsigned int)v11, 512, a3, (_DWORD)a2, 0, v8, v11[0]);
goto LABEL_5;
}
}
}
v9 = strlen(a2);
v4 = v11;
if ( !(unsigned int)my_getwd(v11, (unsigned int)(v6 + 512 - v9), 0) )
{
v10 = strlen(v11);
strmake(&v11[v10], &a2[v6], 512 - v10);
goto LABEL_5;
}
}
v4 = a2;
LABEL_5:
strmake(a1, v4, 511LL);
return a1;
}
| my_load_path:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x218
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP byte ptr [RSI],0x7e
JNZ 0x0014010a
CMP byte ptr [R14 + 0x1],0x2f
JZ 0x00140116
LAB_0014010a:
MOV RDI,R14
CALL 0x0013e44e
TEST EAX,EAX
JZ 0x00140151
LAB_00140116:
MOV R12,R14
LAB_00140119:
MOV EDX,0x1ff
MOV RDI,RBX
MOV RSI,R12
CALL 0x0016cfe0
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001401f8
MOV RAX,RBX
ADD RSP,0x218
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00140151:
CMP byte ptr [R14],0x2e
JNZ 0x00140164
MOV R13D,0x2
CMP byte ptr [R14 + 0x1],0x2f
JZ 0x001401a3
LAB_00140164:
LEA RSI,[0x18ad58]
MOV RDI,R14
CALL 0x0016b6a4
XOR R13D,R13D
TEST R15,R15
JZ 0x001401a3
TEST EAX,EAX
JNZ 0x001401a3
LEA R12,[RBP + -0x240]
MOV ESI,0x200
MOV RDI,R12
MOV RDX,R15
MOV RCX,R14
XOR R8D,R8D
XOR EAX,EAX
CALL 0x0016d100
JMP 0x00140119
LAB_001401a3:
MOV RDI,R14
CALL 0x00133130
LEA ESI,[R13 + 0x200]
SUB ESI,EAX
LEA R12,[RBP + -0x240]
MOV RDI,R12
XOR EDX,EDX
CALL 0x0013e2b8
TEST EAX,EAX
JNZ 0x00140116
MOV RDI,R12
CALL 0x00133130
LEA RDI,[RAX + RBP*0x1]
ADD RDI,-0x240
ADD R14,R13
MOV EDX,0x200
SUB RDX,RAX
MOV RSI,R14
CALL 0x0016cfe0
JMP 0x00140119
LAB_001401f8:
CALL 0x00133370
|
int8 my_load_path(int8 param_1,char *param_2,long param_3)
{
int iVar1;
size_t sVar2;
long lVar3;
long in_FS_OFFSET;
char local_248 [528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (((*param_2 != '~') || (param_2[1] != '/')) && (iVar1 = test_if_hard_path(param_2), iVar1 == 0)
) {
if ((*param_2 != '.') || (lVar3 = 2, param_2[1] != '/')) {
iVar1 = is_prefix(param_2,&DAT_0018ad58);
lVar3 = 0;
if ((param_3 != 0) && (iVar1 == 0)) {
strxnmov(local_248,0x200,param_3,param_2,0);
param_2 = local_248;
goto LAB_00140119;
}
}
sVar2 = strlen(param_2);
iVar1 = my_getwd(local_248,((int)lVar3 + 0x200) - (int)sVar2,0);
if (iVar1 == 0) {
sVar2 = strlen(local_248);
strmake(local_248 + sVar2,param_2 + lVar3,0x200 - sVar2);
param_2 = local_248;
}
}
LAB_00140119:
strmake(param_1,param_2,0x1ff);
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
| |
51,292 | boundary_iterator_init_zh_hans_utf32 | memononen[P]budouxc/src/budoux.c | boundary_iterator_t boundary_iterator_init_zh_hans_utf32(const uint32_t* text, int32_t len)
{
utf_iter_t iter = make_utf32_iter(text, len);
return boundary_iterator_init(&model_zh_hans, iter);
} | O2 | c | boundary_iterator_init_zh_hans_utf32:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq -0x392(%rip), %rax # 0x23c2
testq %rsi, %rsi
je 0x2772
cmpl $0x0, (%rsi)
je 0x2772
testl %edx, %edx
leaq -0x3a5(%rip), %rcx # 0x23c2
leaq -0x23a(%rip), %rax # 0x2534
cmoveq %rcx, %rax
movq %rax, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpl %eax, %edx
cmovbl %edx, %eax
movl %eax, 0x30(%rsp)
andq $0x0, 0x34(%rsp)
andl $0x0, 0x3c(%rsp)
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x13ed1(%rip), %rsi # 0x16680
movq %rbx, %rdi
callq 0x25d8
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
| boundary_iterator_init_zh_hans_utf32:
push rbx
sub rsp, 40h
mov rbx, rdi
lea rax, get_empty
test rsi, rsi
jz short loc_2772
cmp dword ptr [rsi], 0
jz short loc_2772
test edx, edx
lea rcx, get_empty
lea rax, get_utf32
cmovz rax, rcx
loc_2772:
mov qword ptr [rsp+48h+var_28], rax
mov qword ptr [rsp+48h+var_28+8], rsi
mov eax, 7FFFFFFFh
cmp edx, eax
cmovb eax, edx
mov dword ptr [rsp+48h+var_18], eax
and qword ptr [rsp+48h+var_18+4], 0
and dword ptr [rsp+48h+var_18+0Ch], 0
movups xmm0, [rsp+48h+var_28]
movups xmm1, [rsp+48h+var_18]
movups [rsp+48h+var_38], xmm1
movups [rsp+48h+var_48], xmm0
lea rsi, model_zh_hans
mov rdi, rbx
call boundary_iterator_init
mov rax, rbx
add rsp, 40h
pop rbx
retn
| long long boundary_iterator_init_zh_hans_utf32(
long long a1,
_DWORD *a2,
long long a3,
long long ( *a4)(long long a1),
long long a5,
long long a6)
{
long long ( *v6)(long long); // rax
unsigned int v7; // eax
__int128 v9; // [rsp+20h] [rbp-28h]
v6 = get_empty;
if ( a2 )
{
if ( *a2 )
{
a4 = get_empty;
v6 = get_utf32;
if ( !(_DWORD)a3 )
v6 = get_empty;
}
}
*(_QWORD *)&v9 = v6;
*((_QWORD *)&v9 + 1) = a2;
v7 = 0x7FFFFFFF;
if ( (unsigned int)a3 < 0x7FFFFFFF )
v7 = a3;
boundary_iterator_init(a1, (long long)&model_zh_hans, a3, (long long)a4, a5, a6, v9, v7);
return a1;
}
| boundary_iterator_init_zh_hans_utf32:
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
LEA RAX,[0x1023c2]
TEST RSI,RSI
JZ 0x00102772
CMP dword ptr [RSI],0x0
JZ 0x00102772
TEST EDX,EDX
LEA RCX,[0x1023c2]
LEA RAX,[0x102534]
CMOVZ RAX,RCX
LAB_00102772:
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RSI
MOV EAX,0x7fffffff
CMP EDX,EAX
CMOVC EAX,EDX
MOV dword ptr [RSP + 0x30],EAX
AND qword ptr [RSP + 0x34],0x0
AND dword ptr [RSP + 0x3c],0x0
MOVUPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS XMM1,xmmword ptr [RSP + 0x30]
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
LEA RSI,[0x116680]
MOV RDI,RBX
CALL 0x001025d8
MOV RAX,RBX
ADD RSP,0x40
POP RBX
RET
|
int8 boundary_iterator_init_zh_hans_utf32(int8 param_1)
{
boundary_iterator_init(param_1,model_zh_hans);
return param_1;
}
| |
51,293 | boundary_iterator_init_zh_hans_utf32 | memononen[P]budouxc/src/budoux.c | boundary_iterator_t boundary_iterator_init_zh_hans_utf32(const uint32_t* text, int32_t len)
{
utf_iter_t iter = make_utf32_iter(text, len);
return boundary_iterator_init(&model_zh_hans, iter);
} | O3 | c | boundary_iterator_init_zh_hans_utf32:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq -0x3bf(%rip), %rax # 0x2414
testq %rsi, %rsi
je 0x27f1
cmpl $0x0, (%rsi)
je 0x27f1
testl %edx, %edx
leaq -0x3d2(%rip), %rcx # 0x2414
leaq -0x250(%rip), %rax # 0x259d
cmoveq %rcx, %rax
movq %rax, 0x20(%rsp)
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpl %eax, %edx
cmovbl %edx, %eax
movq %rsi, 0x28(%rsp)
movl %eax, 0x30(%rsp)
movq $0x0, 0x34(%rsp)
movl $0x0, 0x3c(%rsp)
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x13e4c(%rip), %rsi # 0x16680
movq %rbx, %rdi
callq 0x2647
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
| boundary_iterator_init_zh_hans_utf32:
push rbx
sub rsp, 40h
mov rbx, rdi
lea rax, get_empty
test rsi, rsi
jz short loc_27F1
cmp dword ptr [rsi], 0
jz short loc_27F1
test edx, edx
lea rcx, get_empty
lea rax, get_utf32
cmovz rax, rcx
loc_27F1:
mov qword ptr [rsp+48h+var_28], rax
mov eax, 7FFFFFFFh
cmp edx, eax
cmovb eax, edx
mov qword ptr [rsp+48h+var_28+8], rsi
mov dword ptr [rsp+48h+var_18], eax
mov qword ptr [rsp+48h+var_18+4], 0
mov dword ptr [rsp+48h+var_18+0Ch], 0
movups xmm0, [rsp+48h+var_28]
movups xmm1, [rsp+48h+var_18]
movups [rsp+48h+var_38], xmm1
movups [rsp+48h+var_48], xmm0
lea rsi, model_zh_hans
mov rdi, rbx
call boundary_iterator_init
mov rax, rbx
add rsp, 40h
pop rbx
retn
| long long boundary_iterator_init_zh_hans_utf32(
long long a1,
_DWORD *a2,
long long a3,
long long ( *a4)(long long a1),
long long a5,
long long a6)
{
long long ( *v6)(long long); // rax
unsigned int v7; // eax
__int128 v9; // [rsp+20h] [rbp-28h]
v6 = get_empty;
if ( a2 )
{
if ( *a2 )
{
a4 = get_empty;
v6 = get_utf32;
if ( !(_DWORD)a3 )
v6 = get_empty;
}
}
*(_QWORD *)&v9 = v6;
v7 = 0x7FFFFFFF;
if ( (unsigned int)a3 < 0x7FFFFFFF )
v7 = a3;
*((_QWORD *)&v9 + 1) = a2;
boundary_iterator_init(a1, (long long)&model_zh_hans, a3, (long long)a4, a5, a6, v9, v7);
return a1;
}
| boundary_iterator_init_zh_hans_utf32:
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
LEA RAX,[0x102414]
TEST RSI,RSI
JZ 0x001027f1
CMP dword ptr [RSI],0x0
JZ 0x001027f1
TEST EDX,EDX
LEA RCX,[0x102414]
LEA RAX,[0x10259d]
CMOVZ RAX,RCX
LAB_001027f1:
MOV qword ptr [RSP + 0x20],RAX
MOV EAX,0x7fffffff
CMP EDX,EAX
CMOVC EAX,EDX
MOV qword ptr [RSP + 0x28],RSI
MOV dword ptr [RSP + 0x30],EAX
MOV qword ptr [RSP + 0x34],0x0
MOV dword ptr [RSP + 0x3c],0x0
MOVUPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS XMM1,xmmword ptr [RSP + 0x30]
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
LEA RSI,[0x116680]
MOV RDI,RBX
CALL 0x00102647
MOV RAX,RBX
ADD RSP,0x40
POP RBX
RET
|
int8 boundary_iterator_init_zh_hans_utf32(int8 param_1)
{
boundary_iterator_init(param_1,model_zh_hans);
return param_1;
}
| |
51,294 | ma_control_file_end | eloqsql/storage/maria/ma_control_file.c | int ma_control_file_end(void)
{
int close_error;
DBUG_ENTER("ma_control_file_end");
if (control_file_fd < 0) /* already closed */
DBUG_RETURN(0);
#ifndef _WIN32
(void) my_lock(control_file_fd, F_UNLCK, 0L, F_TO_EOF,
MYF(MY_SEEK_NOT_DONE | MY_FORCE_LOCK));
#endif
close_error= mysql_file_close(control_file_fd, MYF(MY_WME));
/*
As mysql_file_close() frees structures even if close() fails, we do the
same, i.e. we mark the file as closed in all cases.
*/
control_file_fd= -1;
/*
As this module owns these variables, closing the module forbids access to
them (just a safety):
*/
last_checkpoint_lsn= LSN_IMPOSSIBLE;
last_logno= FILENO_IMPOSSIBLE;
max_trid_in_control_file= recovery_failures= 0;
DBUG_RETURN(close_error);
} | O3 | c | ma_control_file_end:
movl 0x33d449(%rip), %edi # 0x386240
testl %edi, %edi
js 0x48e84
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl $0xa0, %r8d
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa0a30
movl 0x33d41c(%rip), %ebx # 0x386240
leaq 0x33f295(%rip), %rax # 0x3880c0
movq (%rax), %rax
leaq -0x60(%rbp), %rdi
movl %ebx, %esi
movl $0x4, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x48e87
movl $0x10, %esi
movl %ebx, %edi
callq 0xa1461
movl $0xffffffff, 0x33d3e6(%rip) # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movq %rcx, 0x3b69b5(%rip) # 0x3ff818
movl $0x0, 0x3b69b3(%rip) # 0x3ff820
movb $0x0, 0x3b69bc(%rip) # 0x3ff830
movq %rcx, 0x3b69ad(%rip) # 0x3ff828
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
leaq -0x14(%rbp), %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x2a742
movl (%r14), %eax
jmp 0x48e50
| ma_control_file_end:
mov edi, cs:control_file_fd
test edi, edi
js loc_48E84
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 50h
mov r8d, 0A0h
mov esi, 2
xor edx, edx
xor ecx, ecx
call my_lock
mov ebx, cs:control_file_fd
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp-60h]
mov esi, ebx
mov edx, 4
call qword ptr [rax+158h]
test rax, rax
jnz short loc_48E87
mov esi, 10h
mov edi, ebx
call my_close
loc_48E50:
mov cs:control_file_fd, 0FFFFFFFFh
xor ecx, ecx
mov cs:last_checkpoint_lsn, rcx
mov cs:last_logno, 0
mov cs:recovery_failures, 0
mov cs:max_trid_in_control_file, rcx
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_48E84:
xor eax, eax
retn
loc_48E87:
lea r14, [rbp-14h]
mov rdi, rax
mov esi, ebx
mov rdx, r14
call ma_control_file_end_cold_1
mov eax, [r14]
jmp short loc_48E50
| long long ma_control_file_end()
{
unsigned int v0; // ebx
long long v1; // rax
long long result; // rax
long long v3; // [rsp-68h] [rbp-68h] BYREF
unsigned int v4; // [rsp-1Ch] [rbp-1Ch] BYREF
if ( control_file_fd < 0 )
return 0LL;
my_lock((unsigned int)control_file_fd, 2LL, 0LL, 0LL, 160LL);
v0 = control_file_fd;
v1 = ((long long ( *)(long long *, _QWORD, long long))PSI_server[43])(&v3, (unsigned int)control_file_fd, 4LL);
if ( v1 )
{
ma_control_file_end_cold_1(v1, v0, &v4);
result = v4;
}
else
{
result = my_close(v0, 16LL);
}
control_file_fd = -1;
last_checkpoint_lsn = 0LL;
last_logno = 0;
recovery_failures = 0;
max_trid_in_control_file = 0LL;
return result;
}
| ma_control_file_end:
MOV EDI,dword ptr [0x00486240]
TEST EDI,EDI
JS 0x00148e84
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R8D,0xa0
MOV ESI,0x2
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001a0a30
MOV EBX,dword ptr [0x00486240]
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x60]
MOV ESI,EBX
MOV EDX,0x4
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00148e87
MOV ESI,0x10
MOV EDI,EBX
CALL 0x001a1461
LAB_00148e50:
MOV dword ptr [0x00486240],0xffffffff
XOR ECX,ECX
MOV qword ptr [0x004ff818],RCX
MOV dword ptr [0x004ff820],0x0
MOV byte ptr [0x004ff830],0x0
MOV qword ptr [0x004ff828],RCX
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_00148e84:
XOR EAX,EAX
RET
LAB_00148e87:
LEA R14,[RBP + -0x14]
MOV RDI,RAX
MOV ESI,EBX
MOV RDX,R14
CALL 0x0012a742
MOV EAX,dword ptr [R14]
JMP 0x00148e50
|
ulong ma_control_file_end(void)
{
int iVar1;
long lVar2;
ulong uVar3;
int1 local_68 [76];
uint local_1c;
if (-1 < control_file_fd) {
my_lock(control_file_fd,2,0,0,0xa0);
iVar1 = control_file_fd;
lVar2 = (**(code **)(PSI_server + 0x158))(local_68,control_file_fd,4);
if (lVar2 == 0) {
uVar3 = my_close(iVar1,0x10);
}
else {
ma_control_file_end_cold_1(lVar2,iVar1,&local_1c);
uVar3 = (ulong)local_1c;
}
control_file_fd = 0xffffffff;
last_checkpoint_lsn = 0;
last_logno = 0;
recovery_failures = 0;
max_trid_in_control_file = 0;
return uVar3;
}
return 0;
}
| |
51,295 | use_head | eloqsql/storage/maria/ma_bitmap.c | static void use_head(MARIA_HA *info, pgcache_page_no_t page, uint size,
uint block_position)
{
MARIA_FILE_BITMAP *bitmap= &info->s->bitmap;
MARIA_BITMAP_BLOCK *block;
uchar *data;
uint offset, tmp, offset_page;
DBUG_ENTER("use_head");
DBUG_ASSERT(page % bitmap->pages_covered);
block= dynamic_element(&info->bitmap_blocks, block_position,
MARIA_BITMAP_BLOCK*);
block->page= page;
block->page_count= 1 + TAIL_BIT;
block->empty_space= size;
block->used= BLOCKUSED_TAIL;
/*
Mark place used by reading/writing 2 bytes at a time to handle
bitmaps in overlapping bytes
*/
offset_page= (uint) (page - bitmap->page - 1) * 3;
offset= offset_page & 7;
data= bitmap->map + offset_page / 8;
tmp= uint2korr(data);
block->org_bitmap_value= (tmp >> offset) & 7;
tmp= (tmp & ~(7 << offset)) | (FULL_HEAD_PAGE << offset);
int2store(data, tmp);
bitmap->changed= 1;
DBUG_EXECUTE("bitmap", _ma_print_bitmap_changes(bitmap););
DBUG_VOID_RETURN;
} | O0 | c | use_head:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0xa10, %rax # imm = 0xA10
movq %rax, -0x20(%rbp)
jmp 0x5eb55
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rax
movl -0x18(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl $0x8001, 0x8(%rax) # imm = 0x8001
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rax
movb $0x4, 0x14(%rax)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq 0x10(%rcx), %rax
subq $0x1, %rax
imull $0x3, %eax, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x3c(%rbp), %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl -0x34(%rbp), %ecx
shrl %cl, %eax
andl $0x7, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x15(%rax)
movl -0x38(%rbp), %eax
movl -0x34(%rbp), %ecx
movl $0x7, %edx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl -0x34(%rbp), %ecx
movl $0x4, %edx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x38(%rbp), %eax
movw %ax, %cx
movq -0x48(%rbp), %rax
movw %cx, (%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x20(%rax)
jmp 0x5ec2e
jmp 0x5ec30
jmp 0x5ec32
popq %rbp
retq
nopw %cs:(%rax,%rax)
| use_head:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
mov rax, [rbp+var_8]
mov rax, [rax]
add rax, 0A10h
mov [rbp+var_20], rax
jmp short $+2
loc_5EB55:
mov rax, [rbp+var_8]
mov rax, [rax+2C0h]
mov ecx, [rbp+var_18]
imul rcx, 18h
add rax, rcx
mov [rbp+var_28], rax
mov rcx, [rbp+var_10]
mov rax, [rbp+var_28]
mov [rax], rcx
mov rax, [rbp+var_28]
mov dword ptr [rax+8], 8001h
mov ecx, [rbp+var_14]
mov rax, [rbp+var_28]
mov [rax+0Ch], ecx
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 4
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
sub rax, [rcx+10h]
sub rax, 1
imul eax, 3
mov [rbp+var_3C], eax
mov eax, [rbp+var_3C]
and eax, 7
mov [rbp+var_34], eax
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov ecx, [rbp+var_3C]
shr ecx, 3
mov ecx, ecx
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax]
mov [rbp+var_38], eax
mov eax, [rbp+var_38]
mov ecx, [rbp+var_34]
shr eax, cl
and eax, 7
mov cl, al
mov rax, [rbp+var_28]
mov [rax+15h], cl
mov eax, [rbp+var_38]
mov ecx, [rbp+var_34]
mov edx, 7
shl edx, cl
mov ecx, edx
xor ecx, 0FFFFFFFFh
and eax, ecx
mov ecx, [rbp+var_34]
mov edx, 4
shl edx, cl
mov ecx, edx
or eax, ecx
mov [rbp+var_38], eax
mov rax, [rbp+var_30]
mov [rbp+var_48], rax
mov eax, [rbp+var_38]
mov cx, ax
mov rax, [rbp+var_48]
mov [rax], cx
mov rax, [rbp+var_20]
mov byte ptr [rax+20h], 1
jmp short $+2
loc_5EC2E:
jmp short $+2
loc_5EC30:
jmp short $+2
loc_5EC32:
pop rbp
retn
| long long use_head(_QWORD *a1, long long a2, int a3, unsigned int a4)
{
long long result; // rax
unsigned int v5; // [rsp+Ch] [rbp-3Ch]
unsigned int v6; // [rsp+10h] [rbp-38h]
_WORD *v7; // [rsp+18h] [rbp-30h]
long long v8; // [rsp+20h] [rbp-28h]
long long v9; // [rsp+28h] [rbp-20h]
v9 = *a1 + 2576LL;
v8 = 24LL * a4 + a1[88];
*(_QWORD *)v8 = a2;
*(_DWORD *)(v8 + 8) = 32769;
*(_DWORD *)(v8 + 12) = a3;
*(_BYTE *)(v8 + 20) = 4;
v5 = 3 * (a2 - *(_DWORD *)(v9 + 16) - 1);
v7 = (_WORD *)((v5 >> 3) + *(_QWORD *)(v9 + 8));
v6 = (unsigned __int16)*v7;
*(_BYTE *)(v8 + 21) = (v6 >> (v5 & 7)) & 7;
*v7 = (4 << (v5 & 7)) | ~(7 << (v5 & 7)) & v6;
result = v9;
*(_BYTE *)(v9 + 32) = 1;
return result;
}
| use_head:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x18],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
ADD RAX,0xa10
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0015eb55
LAB_0015eb55:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2c0]
MOV ECX,dword ptr [RBP + -0x18]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x8],0x8001
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x4
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,qword ptr [RCX + 0x10]
SUB RAX,0x1
IMUL EAX,EAX,0x3
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
AND EAX,0x7
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x3c]
SHR ECX,0x3
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
MOV EAX,dword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x34]
SHR EAX,CL
AND EAX,0x7
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],CL
MOV EAX,dword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x34]
MOV EDX,0x7
SHL EDX,CL
MOV ECX,EDX
XOR ECX,0xffffffff
AND EAX,ECX
MOV ECX,dword ptr [RBP + -0x34]
MOV EDX,0x4
SHL EDX,CL
MOV ECX,EDX
OR EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0x38]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x48]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x20],0x1
JMP 0x0015ec2e
LAB_0015ec2e:
JMP 0x0015ec30
LAB_0015ec30:
JMP 0x0015ec32
LAB_0015ec32:
POP RBP
RET
|
void use_head(long *param_1,int8 param_2,int4 param_3,uint param_4)
{
ushort uVar1;
long lVar2;
uint uVar3;
int8 *puVar4;
ushort *puVar5;
byte bVar6;
lVar2 = *param_1;
puVar4 = (int8 *)(param_1[0x58] + (ulong)param_4 * 0x18);
*puVar4 = param_2;
*(int4 *)(puVar4 + 1) = 0x8001;
*(int4 *)((long)puVar4 + 0xc) = param_3;
*(int1 *)((long)puVar4 + 0x14) = 4;
uVar3 = (((int)param_2 - (int)*(int8 *)(lVar2 + 0xa20)) + -1) * 3;
bVar6 = (byte)uVar3 & 7;
puVar5 = (ushort *)(*(long *)(lVar2 + 0xa18) + (ulong)(uVar3 >> 3));
uVar1 = *puVar5;
*(byte *)((long)puVar4 + 0x15) = (byte)(uVar1 >> bVar6) & 7;
*puVar5 = uVar1 & ((ushort)(7 << bVar6) ^ 0xffff) | (ushort)(4 << bVar6);
*(int1 *)(lVar2 + 0xa30) = 1;
return;
}
| |
51,296 | my_strntod_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static double
my_strntod_mb2_or_mb4(CHARSET_INFO *cs,
char *nptr, size_t length,
char **endptr, int *err)
{
char buf[256];
double res;
register char *b= buf;
register const uchar *s= (const uchar*) nptr;
const uchar *end;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
int cnv;
*err= 0;
/* Cut too long strings */
if (length >= sizeof(buf))
length= sizeof(buf) - 1;
end= s + length;
while ((cnv= mb_wc(cs, &wc, s, end)) > 0)
{
s+= cnv;
if (wc > (int) (uchar) 'e' || !wc)
break; /* Can't be part of double */
*b++= (char) wc;
}
*endptr= b;
res= my_strtod(buf, endptr, err);
*endptr= nptr + cs->mbminlen * (size_t) (*endptr - buf);
return res;
} | O3 | c | my_strntod_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, -0x150(%rbp)
movq %rsi, %rcx
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rbx
movq %r8, -0x148(%rbp)
movl $0x0, (%r8)
movl $0xff, %r13d
cmpq %r13, %rdx
cmovbq %rdx, %r13
addq %rsi, %r13
leaq -0x140(%rbp), %rsi
movq %rcx, -0x138(%rbp)
movq %rcx, %rdx
movq %r13, %rcx
callq *%rbx
leaq -0x130(%rbp), %r12
testl %eax, %eax
jle 0xc9d75
movq -0x138(%rbp), %r14
movq -0x140(%rbp), %rcx
leaq -0x1(%rcx), %rdx
cmpq $0x64, %rdx
ja 0xc9d75
movl %eax, %eax
addq %rax, %r14
movb %cl, (%r12)
incq %r12
movq %r15, %rdi
leaq -0x140(%rbp), %rsi
movq %r14, %rdx
movq %r13, %rcx
callq *%rbx
testl %eax, %eax
jg 0xc9d42
movq -0x150(%rbp), %rbx
movq %r12, (%rbx)
leaq -0x130(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq -0x148(%rbp), %rdx
callq 0xd98f0
movl 0x98(%r15), %eax
movq (%rbx), %rcx
subq %r14, %rcx
imulq %rax, %rcx
movq -0x138(%rbp), %rax
addq %rcx, %rax
movq %rax, (%rbx)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xc9dd7
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x39290
| my_strntod_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 128h
mov [rbp+var_150], rcx
mov rcx, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi+0B8h]
mov rbx, [rax+28h]
mov [rbp+var_148], r8
mov dword ptr [r8], 0
mov r13d, 0FFh
cmp rdx, r13
cmovb r13, rdx
add r13, rsi
lea rsi, [rbp+var_140]
mov [rbp+var_138], rcx
mov rdx, rcx
mov rcx, r13
call rbx
lea r12, [rbp+var_130]
test eax, eax
jle short loc_C9D75
mov r14, [rbp+var_138]
loc_C9D42:
mov rcx, [rbp+var_140]
lea rdx, [rcx-1]
cmp rdx, 64h ; 'd'
ja short loc_C9D75
mov eax, eax
add r14, rax
mov [r12], cl
inc r12
mov rdi, r15
lea rsi, [rbp+var_140]
mov rdx, r14
mov rcx, r13
call rbx
test eax, eax
jg short loc_C9D42
loc_C9D75:
mov rbx, [rbp+var_150]
mov [rbx], r12
lea r14, [rbp+var_130]
mov rdi, r14
mov rsi, rbx
mov rdx, [rbp+var_148]
call my_strtod
mov eax, [r15+98h]
mov rcx, [rbx]
sub rcx, r14
imul rcx, rax
mov rax, [rbp+var_138]
add rax, rcx
mov [rbx], rax
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_C9DD7
add rsp, 128h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_C9DD7:
call ___stack_chk_fail
| unsigned long long my_strntod_mb2_or_mb4(long long a1, long long a2, unsigned long long a3, _QWORD *a4, _DWORD *a5)
{
long long ( *v5)(long long, long long *, long long, long long); // rbx
long long v6; // r13
long long v7; // r13
int v8; // eax
_BYTE *v9; // r12
long long v10; // r14
long long v14; // [rsp+10h] [rbp-140h] BYREF
long long v15; // [rsp+18h] [rbp-138h]
_BYTE v16[256]; // [rsp+20h] [rbp-130h] BYREF
unsigned long long v17; // [rsp+120h] [rbp-30h]
v17 = __readfsqword(0x28u);
v5 = *(long long ( **)(long long, long long *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
*a5 = 0;
v6 = 255LL;
if ( a3 < 0xFF )
v6 = a3;
v7 = a2 + v6;
v15 = a2;
v8 = v5(a1, &v14, a2, v7);
v9 = v16;
if ( v8 > 0 )
{
v10 = v15;
do
{
if ( (unsigned long long)(v14 - 1) > 0x64 )
break;
v10 += (unsigned int)v8;
*v9++ = v14;
v8 = v5(a1, &v14, v10, v7);
}
while ( v8 > 0 );
}
*a4 = v9;
my_strtod(v16, a4, a5);
*a4 = *(unsigned int *)(a1 + 152) * (*a4 - (_QWORD)v16) + v15;
return __readfsqword(0x28u);
}
| my_strntod_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x128
MOV qword ptr [RBP + -0x150],RCX
MOV RCX,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RBX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x148],R8
MOV dword ptr [R8],0x0
MOV R13D,0xff
CMP RDX,R13
CMOVC R13,RDX
ADD R13,RSI
LEA RSI,[RBP + -0x140]
MOV qword ptr [RBP + -0x138],RCX
MOV RDX,RCX
MOV RCX,R13
CALL RBX
LEA R12,[RBP + -0x130]
TEST EAX,EAX
JLE 0x001c9d75
MOV R14,qword ptr [RBP + -0x138]
LAB_001c9d42:
MOV RCX,qword ptr [RBP + -0x140]
LEA RDX,[RCX + -0x1]
CMP RDX,0x64
JA 0x001c9d75
MOV EAX,EAX
ADD R14,RAX
MOV byte ptr [R12],CL
INC R12
MOV RDI,R15
LEA RSI,[RBP + -0x140]
MOV RDX,R14
MOV RCX,R13
CALL RBX
TEST EAX,EAX
JG 0x001c9d42
LAB_001c9d75:
MOV RBX,qword ptr [RBP + -0x150]
MOV qword ptr [RBX],R12
LEA R14,[RBP + -0x130]
MOV RDI,R14
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x148]
CALL 0x001d98f0
MOV EAX,dword ptr [R15 + 0x98]
MOV RCX,qword ptr [RBX]
SUB RCX,R14
IMUL RCX,RAX
MOV RAX,qword ptr [RBP + -0x138]
ADD RAX,RCX
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001c9dd7
ADD RSP,0x128
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001c9dd7:
CALL 0x00139290
|
void my_strntod_mb2_or_mb4
(long param_1,long param_2,ulong param_3,long *param_4,int4 *param_5)
{
code *pcVar1;
uint uVar2;
int1 *puVar3;
ulong uVar4;
long lVar5;
long in_FS_OFFSET;
long local_148;
long local_140;
int1 local_138 [256];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
*param_5 = 0;
uVar4 = 0xff;
if (param_3 < 0xff) {
uVar4 = param_3;
}
local_140 = param_2;
uVar2 = (*pcVar1)(param_1,&local_148,param_2,uVar4 + param_2);
puVar3 = local_138;
lVar5 = local_140;
while ((0 < (int)uVar2 && (local_148 - 1U < 0x65))) {
lVar5 = lVar5 + (ulong)uVar2;
*puVar3 = (char)local_148;
puVar3 = puVar3 + 1;
uVar2 = (*pcVar1)(param_1,&local_148,lVar5,uVar4 + param_2);
}
*param_4 = (long)puVar3;
my_strtod(local_138,param_4,param_5);
*param_4 = local_140 + (*param_4 - (long)local_138) * (ulong)*(uint *)(param_1 + 0x98);
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
51,297 | lf_hash_destroy | eloqsql/mysys/lf_hash.cc | void lf_hash_destroy(LF_HASH *hash)
{
LF_SLIST *el, **head= (LF_SLIST **)lf_dynarray_value(&hash->array, 0);
if (head)
{
el= *head;
while (el)
{
intptr next= el->link;
if (el->hashnr & 1)
lf_alloc_direct_free(&hash->alloc, el); /* normal node */
else
my_free(el); /* dummy node */
el= (LF_SLIST *)next;
}
}
lf_alloc_destroy(&hash->alloc);
lf_dynarray_destroy(&hash->array);
} | O3 | cpp | lf_hash_destroy:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0xa56a4
testq %rax, %rax
je 0xa593e
movq (%rax), %r14
testq %r14, %r14
je 0xa593e
movq (%r14), %r15
testb $0x1, 0x18(%r14)
je 0xa592e
movq 0x88(%rbx), %rax
testq %rax, %rax
je 0xa592e
movq %r14, %rdi
callq *%rax
movq %r14, %rdi
callq 0x9fbaa
movq %r15, %r14
testq %r15, %r15
jne 0xa5913
leaq 0x28(%rbx), %rdi
callq 0xa5455
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa5623
| lf_hash_destroy:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
xor esi, esi
call lf_dynarray_value
test rax, rax
jz short loc_A593E
mov r14, [rax]
test r14, r14
jz short loc_A593E
loc_A5913:
mov r15, [r14]
test byte ptr [r14+18h], 1
jz short loc_A592E
mov rax, [rbx+88h]
test rax, rax
jz short loc_A592E
mov rdi, r14
call rax
loc_A592E:
mov rdi, r14
call my_free
mov r14, r15
test r15, r15
jnz short loc_A5913
loc_A593E:
lea rdi, [rbx+28h]
call lf_alloc_destroy
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp lf_dynarray_destroy
| long long lf_hash_destroy(long long a1)
{
long long *v1; // rax
long long v2; // r14
long long v3; // r15
void ( *v4)(long long); // rax
v1 = (long long *)lf_dynarray_value(a1, 0);
if ( v1 )
{
v2 = *v1;
if ( *v1 )
{
do
{
v3 = *(_QWORD *)v2;
if ( (*(_BYTE *)(v2 + 24) & 1) != 0 )
{
v4 = *(void ( **)(long long))(a1 + 136);
if ( v4 )
v4(v2);
}
my_free(v2);
v2 = v3;
}
while ( v3 );
}
}
lf_alloc_destroy(a1 + 40);
return lf_dynarray_destroy(a1);
}
| lf_hash_destroy:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
XOR ESI,ESI
CALL 0x001a56a4
TEST RAX,RAX
JZ 0x001a593e
MOV R14,qword ptr [RAX]
TEST R14,R14
JZ 0x001a593e
LAB_001a5913:
MOV R15,qword ptr [R14]
TEST byte ptr [R14 + 0x18],0x1
JZ 0x001a592e
MOV RAX,qword ptr [RBX + 0x88]
TEST RAX,RAX
JZ 0x001a592e
MOV RDI,R14
CALL RAX
LAB_001a592e:
MOV RDI,R14
CALL 0x0019fbaa
MOV R14,R15
TEST R15,R15
JNZ 0x001a5913
LAB_001a593e:
LEA RDI,[RBX + 0x28]
CALL 0x001a5455
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001a5623
|
void lf_hash_destroy(long param_1)
{
int8 *puVar1;
int8 *puVar2;
puVar2 = (int8 *)lf_dynarray_value(param_1,0);
if (puVar2 != (int8 *)0x0) {
puVar2 = (int8 *)*puVar2;
while (puVar2 != (int8 *)0x0) {
puVar1 = (int8 *)*puVar2;
if (((*(byte *)(puVar2 + 3) & 1) != 0) && (*(code **)(param_1 + 0x88) != (code *)0x0)) {
(**(code **)(param_1 + 0x88))(puVar2);
}
my_free(puVar2);
puVar2 = puVar1;
}
}
lf_alloc_destroy(param_1 + 0x28);
lf_dynarray_destroy(param_1);
return;
}
| |
51,298 | LefDefParser::lefiViaRule::addNumProp(char const*, double, char const*, char) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiViaRule.cpp | void
lefiViaRule::addNumProp(const char *name,
const double d,
const char *value,
const char type)
{
int len = strlen(name) + 1;
if (numProps_ == propsAllocated_) {
int i;
int max;
int lim;
char **nn;
char **nv;
double *nd;
char *nt;
if (propsAllocated_ == 0)
propsAllocated_ = 1; // initialize propsAllocated_
max = propsAllocated_ *= 2;
lim = numProps_;
nn = (char**) lefMalloc(sizeof(char*) * max);
nv = (char**) lefMalloc(sizeof(char*) * max);
nd = (double*) lefMalloc(sizeof(double) * max);
nt = (char*) lefMalloc(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];
}
lefFree((char*) (names_));
lefFree((char*) (values_));
lefFree((char*) (dvalues_));
lefFree((char*) (types_));
names_ = nn;
values_ = nv;
dvalues_ = nd;
types_ = nt;
}
names_[numProps_] = (char*) lefMalloc(sizeof(char) * len);
strcpy(names_[numProps_], name);
len = strlen(value) + 1;
values_[numProps_] = (char*) lefMalloc(sizeof(char) * len);
strcpy(values_[numProps_], value);
dvalues_[numProps_] = d;
types_[numProps_] = type;
numProps_ += 1;
} | O0 | cpp | LefDefParser::lefiViaRule::addNumProp(char const*, double, char const*, char):
subq $0x68, %rsp
movb %cl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movsd %xmm0, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movb %al, 0x47(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x20d0
movq 0x8(%rsp), %rcx
addq $0x1, %rax
movl %eax, 0x40(%rsp)
movl 0x1d8(%rcx), %eax
cmpl 0x1dc(%rcx), %eax
jne 0x308c8
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1dc(%rax)
jne 0x3073f
movq 0x8(%rsp), %rax
movl $0x1, 0x1dc(%rax)
movq 0x8(%rsp), %rax
movl 0x1dc(%rax), %ecx
shll %ecx
movl %ecx, 0x1dc(%rax)
movl %ecx, 0x38(%rsp)
movl 0x1d8(%rax), %eax
movl %eax, 0x34(%rsp)
movslq 0x38(%rsp), %rdi
shlq $0x3, %rdi
callq 0x359d0
movq %rax, 0x28(%rsp)
movslq 0x38(%rsp), %rdi
shlq $0x3, %rdi
callq 0x359d0
movq %rax, 0x20(%rsp)
movslq 0x38(%rsp), %rdi
shlq $0x3, %rdi
callq 0x359d0
movq %rax, 0x18(%rsp)
movslq 0x38(%rsp), %rdi
shlq $0x0, %rdi
callq 0x359d0
movq %rax, 0x10(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x3084f
movq 0x8(%rsp), %rax
movq 0x1e0(%rax), %rcx
movslq 0x3c(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x28(%rsp), %rcx
movslq 0x3c(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x1e8(%rax), %rcx
movslq 0x3c(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x20(%rsp), %rcx
movslq 0x3c(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x1f0(%rax), %rcx
movslq 0x3c(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x18(%rsp), %rcx
movslq 0x3c(%rsp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x1f8(%rax), %rax
movslq 0x3c(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movslq 0x3c(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x307b4
movq 0x8(%rsp), %rax
movq 0x1e0(%rax), %rdi
callq 0x38c90
movq 0x8(%rsp), %rax
movq 0x1e8(%rax), %rdi
callq 0x38c90
movq 0x8(%rsp), %rax
movq 0x1f0(%rax), %rdi
callq 0x38c90
movq 0x8(%rsp), %rax
movq 0x1f8(%rax), %rdi
callq 0x38c90
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x1e0(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x1e8(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x1f0(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x1f8(%rax)
movslq 0x40(%rsp), %rdi
shlq $0x0, %rdi
callq 0x359d0
movq 0x8(%rsp), %rcx
movq %rax, %rsi
movq 0x1e0(%rcx), %rax
movslq 0x1d8(%rcx), %rdx
movq %rsi, (%rax,%rdx,8)
movq 0x1e0(%rcx), %rax
movslq 0x1d8(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x58(%rsp), %rsi
callq 0x2250
movq 0x48(%rsp), %rdi
callq 0x20d0
addq $0x1, %rax
movl %eax, 0x40(%rsp)
movslq 0x40(%rsp), %rdi
shlq $0x0, %rdi
callq 0x359d0
movq 0x8(%rsp), %rcx
movq %rax, %rsi
movq 0x1e8(%rcx), %rax
movslq 0x1d8(%rcx), %rdx
movq %rsi, (%rax,%rdx,8)
movq 0x1e8(%rcx), %rax
movslq 0x1d8(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x48(%rsp), %rsi
callq 0x2250
movq 0x8(%rsp), %rax
movsd 0x50(%rsp), %xmm0
movq 0x1f0(%rax), %rcx
movslq 0x1d8(%rax), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movb 0x47(%rsp), %sil
movq 0x1f8(%rax), %rcx
movslq 0x1d8(%rax), %rdx
movb %sil, (%rcx,%rdx)
movl 0x1d8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1d8(%rax)
addq $0x68, %rsp
retq
nopl (%rax,%rax)
| _ZN12LefDefParser11lefiViaRule10addNumPropEPKcdS2_c:
sub rsp, 68h
mov al, cl
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
movsd [rsp+68h+var_18], xmm0
mov [rsp+68h+var_20], rdx
mov [rsp+68h+var_21], al
mov rax, [rsp+68h+var_8]
mov [rsp+68h+var_60], rax
mov rdi, [rsp+68h+var_10]
call _strlen
mov rcx, [rsp+68h+var_60]
add rax, 1
mov [rsp+68h+var_28], eax
mov eax, [rcx+1D8h]
cmp eax, [rcx+1DCh]
jnz loc_308C8
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+1DCh], 0
jnz short loc_3073F
mov rax, [rsp+68h+var_60]
mov dword ptr [rax+1DCh], 1
loc_3073F:
mov rax, [rsp+68h+var_60]
mov ecx, [rax+1DCh]
shl ecx, 1
mov [rax+1DCh], ecx
mov [rsp+68h+var_30], ecx
mov eax, [rax+1D8h]
mov [rsp+68h+var_34], eax
movsxd rdi, [rsp+68h+var_30]
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [rsp+68h+var_40], rax
movsxd rdi, [rsp+68h+var_30]
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [rsp+68h+var_48], rax
movsxd rdi, [rsp+68h+var_30]
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [rsp+68h+var_50], rax
movsxd rdi, [rsp+68h+var_30]
shl rdi, 0; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [rsp+68h+var_58], rax
mov [rsp+68h+var_2C], 0
loc_307B4:
mov eax, [rsp+68h+var_2C]
cmp eax, [rsp+68h+var_34]
jge loc_3084F
mov rax, [rsp+68h+var_60]
mov rcx, [rax+1E0h]
movsxd rdx, [rsp+68h+var_2C]
mov rsi, [rcx+rdx*8]
mov rcx, [rsp+68h+var_40]
movsxd rdx, [rsp+68h+var_2C]
mov [rcx+rdx*8], rsi
mov rcx, [rax+1E8h]
movsxd rdx, [rsp+68h+var_2C]
mov rsi, [rcx+rdx*8]; unsigned __int64
mov rcx, [rsp+68h+var_48]
movsxd rdx, [rsp+68h+var_2C]
mov [rcx+rdx*8], rsi
mov rcx, [rax+1F0h]
movsxd rdx, [rsp+68h+var_2C]
movsd xmm0, qword ptr [rcx+rdx*8]
mov rcx, [rsp+68h+var_50]
movsxd rdx, [rsp+68h+var_2C]
movsd qword ptr [rcx+rdx*8], xmm0
mov rax, [rax+1F8h]
movsxd rcx, [rsp+68h+var_2C]
mov dl, [rax+rcx]
mov rax, [rsp+68h+var_58]
movsxd rcx, [rsp+68h+var_2C]
mov [rax+rcx], dl
mov eax, [rsp+68h+var_2C]
add eax, 1
mov [rsp+68h+var_2C], eax
jmp loc_307B4
loc_3084F:
mov rax, [rsp+68h+var_60]
mov rdi, [rax+1E0h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rax, [rsp+68h+var_60]
mov rdi, [rax+1E8h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rax, [rsp+68h+var_60]
mov rdi, [rax+1F0h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rax, [rsp+68h+var_60]
mov rdi, [rax+1F8h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rax, [rsp+68h+var_60]
mov rcx, [rsp+68h+var_40]
mov [rax+1E0h], rcx
mov rcx, [rsp+68h+var_48]
mov [rax+1E8h], rcx
mov rcx, [rsp+68h+var_50]
mov [rax+1F0h], rcx
mov rcx, [rsp+68h+var_58]
mov [rax+1F8h], rcx
loc_308C8:
movsxd rdi, [rsp+68h+var_28]
shl rdi, 0; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rcx, [rsp+68h+var_60]
mov rsi, rax
mov rax, [rcx+1E0h]
movsxd rdx, dword ptr [rcx+1D8h]
mov [rax+rdx*8], rsi
mov rax, [rcx+1E0h]
movsxd rcx, dword ptr [rcx+1D8h]
mov rdi, [rax+rcx*8]
mov rsi, [rsp+68h+var_10]; unsigned __int64
call _strcpy
mov rdi, [rsp+68h+var_20]
call _strlen
add rax, 1
mov [rsp+68h+var_28], eax
movsxd rdi, [rsp+68h+var_28]
shl rdi, 0; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rcx, [rsp+68h+var_60]
mov rsi, rax
mov rax, [rcx+1E8h]
movsxd rdx, dword ptr [rcx+1D8h]
mov [rax+rdx*8], rsi
mov rax, [rcx+1E8h]
movsxd rcx, dword ptr [rcx+1D8h]
mov rdi, [rax+rcx*8]
mov rsi, [rsp+68h+var_20]
call _strcpy
mov rax, [rsp+68h+var_60]
movsd xmm0, [rsp+68h+var_18]
mov rcx, [rax+1F0h]
movsxd rdx, dword ptr [rax+1D8h]
movsd qword ptr [rcx+rdx*8], xmm0
mov sil, [rsp+68h+var_21]
mov rcx, [rax+1F8h]
movsxd rdx, dword ptr [rax+1D8h]
mov [rcx+rdx], sil
mov ecx, [rax+1D8h]
add ecx, 1
mov [rax+1D8h], ecx
add rsp, 68h
retn
| LefDefParser::lefiViaRule * LefDefParser::lefiViaRule::addNumProp(
LefDefParser::lefiViaRule *this,
char *a2,
double a3,
const char *a4,
char a5)
{
int v5; // ecx
LefDefParser::lefiViaRule *result; // rax
long long v7; // [rsp+10h] [rbp-58h]
long long v8; // [rsp+18h] [rbp-50h]
long long v9; // [rsp+20h] [rbp-48h]
long long v10; // [rsp+28h] [rbp-40h]
int v11; // [rsp+34h] [rbp-34h]
int v12; // [rsp+38h] [rbp-30h]
int i; // [rsp+3Ch] [rbp-2Ch]
int v14; // [rsp+40h] [rbp-28h]
int v15; // [rsp+40h] [rbp-28h]
const char *v18; // [rsp+58h] [rbp-10h]
v18 = a2;
v14 = strlen(a2) + 1;
if ( *((_DWORD *)this + 118) == *((_DWORD *)this + 119) )
{
if ( !*((_DWORD *)this + 119) )
*((_DWORD *)this + 119) = 1;
v5 = 2 * *((_DWORD *)this + 119);
*((_DWORD *)this + 119) = v5;
v12 = v5;
v11 = *((_DWORD *)this + 118);
v10 = LefDefParser::lefMalloc((LefDefParser *)(8LL * v5), (unsigned long long)a2);
v9 = LefDefParser::lefMalloc((LefDefParser *)(8LL * v12), (unsigned long long)a2);
v8 = LefDefParser::lefMalloc((LefDefParser *)(8LL * v12), (unsigned long long)a2);
v7 = LefDefParser::lefMalloc((LefDefParser *)v12, (unsigned long long)a2);
for ( i = 0; i < v11; ++i )
{
*(_QWORD *)(v10 + 8LL * i) = *(_QWORD *)(*((_QWORD *)this + 60) + 8LL * i);
a2 = *(char **)(*((_QWORD *)this + 61) + 8LL * i);
*(_QWORD *)(v9 + 8LL * i) = a2;
*(_QWORD *)(v8 + 8LL * i) = *(_QWORD *)(*((_QWORD *)this + 62) + 8LL * i);
*(_BYTE *)(v7 + i) = *(_BYTE *)(*((_QWORD *)this + 63) + i);
}
LefDefParser::lefFree(*((LefDefParser **)this + 60), a2);
LefDefParser::lefFree(*((LefDefParser **)this + 61), a2);
LefDefParser::lefFree(*((LefDefParser **)this + 62), a2);
LefDefParser::lefFree(*((LefDefParser **)this + 63), a2);
*((_QWORD *)this + 60) = v10;
*((_QWORD *)this + 61) = v9;
*((_QWORD *)this + 62) = v8;
*((_QWORD *)this + 63) = v7;
}
*(_QWORD *)(*((_QWORD *)this + 60) + 8LL * *((int *)this + 118)) = LefDefParser::lefMalloc(
(LefDefParser *)v14,
(unsigned long long)a2);
strcpy(*(_QWORD *)(*((_QWORD *)this + 60) + 8LL * *((int *)this + 118)), v18);
v15 = strlen(a4) + 1;
*(_QWORD *)(*((_QWORD *)this + 61) + 8LL * *((int *)this + 118)) = LefDefParser::lefMalloc(
(LefDefParser *)v15,
(unsigned long long)v18);
strcpy(*(_QWORD *)(*((_QWORD *)this + 61) + 8LL * *((int *)this + 118)), a4);
result = this;
*(double *)(*((_QWORD *)this + 62) + 8LL * *((int *)this + 118)) = a3;
*(_BYTE *)(*((_QWORD *)this + 63) + (int)(*((_DWORD *)this + 118))++) = a5;
return result;
}
| addNumProp:
SUB RSP,0x68
MOV AL,CL
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
MOVSD qword ptr [RSP + 0x50],XMM0
MOV qword ptr [RSP + 0x48],RDX
MOV byte ptr [RSP + 0x47],AL
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x001020d0
MOV RCX,qword ptr [RSP + 0x8]
ADD RAX,0x1
MOV dword ptr [RSP + 0x40],EAX
MOV EAX,dword ptr [RCX + 0x1d8]
CMP EAX,dword ptr [RCX + 0x1dc]
JNZ 0x001308c8
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x1dc],0x0
JNZ 0x0013073f
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX + 0x1dc],0x1
LAB_0013073f:
MOV RAX,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RAX + 0x1dc]
SHL ECX,0x1
MOV dword ptr [RAX + 0x1dc],ECX
MOV dword ptr [RSP + 0x38],ECX
MOV EAX,dword ptr [RAX + 0x1d8]
MOV dword ptr [RSP + 0x34],EAX
MOVSXD RDI,dword ptr [RSP + 0x38]
SHL RDI,0x3
CALL 0x001359d0
MOV qword ptr [RSP + 0x28],RAX
MOVSXD RDI,dword ptr [RSP + 0x38]
SHL RDI,0x3
CALL 0x001359d0
MOV qword ptr [RSP + 0x20],RAX
MOVSXD RDI,dword ptr [RSP + 0x38]
SHL RDI,0x3
CALL 0x001359d0
MOV qword ptr [RSP + 0x18],RAX
MOVSXD RDI,dword ptr [RSP + 0x38]
SHL RDI,0x0
CALL 0x001359d0
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x3c],0x0
LAB_001307b4:
MOV EAX,dword ptr [RSP + 0x3c]
CMP EAX,dword ptr [RSP + 0x34]
JGE 0x0013084f
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX + 0x1e0]
MOVSXD RDX,dword ptr [RSP + 0x3c]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x28]
MOVSXD RDX,dword ptr [RSP + 0x3c]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RCX,qword ptr [RAX + 0x1e8]
MOVSXD RDX,dword ptr [RSP + 0x3c]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x20]
MOVSXD RDX,dword ptr [RSP + 0x3c]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RCX,qword ptr [RAX + 0x1f0]
MOVSXD RDX,dword ptr [RSP + 0x3c]
MOVSD XMM0,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x18]
MOVSXD RDX,dword ptr [RSP + 0x3c]
MOVSD qword ptr [RCX + RDX*0x8],XMM0
MOV RAX,qword ptr [RAX + 0x1f8]
MOVSXD RCX,dword ptr [RSP + 0x3c]
MOV DL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RSP + 0x10]
MOVSXD RCX,dword ptr [RSP + 0x3c]
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RSP + 0x3c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x3c],EAX
JMP 0x001307b4
LAB_0013084f:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x1e0]
CALL 0x00138c90
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x1e8]
CALL 0x00138c90
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x1f0]
CALL 0x00138c90
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x1f8]
CALL 0x00138c90
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x1e0],RCX
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x1e8],RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x1f0],RCX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x1f8],RCX
LAB_001308c8:
MOVSXD RDI,dword ptr [RSP + 0x40]
SHL RDI,0x0
CALL 0x001359d0
MOV RCX,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV RAX,qword ptr [RCX + 0x1e0]
MOVSXD RDX,dword ptr [RCX + 0x1d8]
MOV qword ptr [RAX + RDX*0x8],RSI
MOV RAX,qword ptr [RCX + 0x1e0]
MOVSXD RCX,dword ptr [RCX + 0x1d8]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00102250
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x001020d0
ADD RAX,0x1
MOV dword ptr [RSP + 0x40],EAX
MOVSXD RDI,dword ptr [RSP + 0x40]
SHL RDI,0x0
CALL 0x001359d0
MOV RCX,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV RAX,qword ptr [RCX + 0x1e8]
MOVSXD RDX,dword ptr [RCX + 0x1d8]
MOV qword ptr [RAX + RDX*0x8],RSI
MOV RAX,qword ptr [RCX + 0x1e8]
MOVSXD RCX,dword ptr [RCX + 0x1d8]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00102250
MOV RAX,qword ptr [RSP + 0x8]
MOVSD XMM0,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RAX + 0x1f0]
MOVSXD RDX,dword ptr [RAX + 0x1d8]
MOVSD qword ptr [RCX + RDX*0x8],XMM0
MOV SIL,byte ptr [RSP + 0x47]
MOV RCX,qword ptr [RAX + 0x1f8]
MOVSXD RDX,dword ptr [RAX + 0x1d8]
MOV byte ptr [RCX + RDX*0x1],SIL
MOV ECX,dword ptr [RAX + 0x1d8]
ADD ECX,0x1
MOV dword ptr [RAX + 0x1d8],ECX
ADD RSP,0x68
RET
|
/* LefDefParser::lefiViaRule::addNumProp(char const*, double, char const*, char) */
void __thiscall
LefDefParser::lefiViaRule::addNumProp
(lefiViaRule *this,char *param_1,double param_2,char *param_3,char param_4)
{
int iVar1;
size_t sVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
int8 uVar7;
int iVar8;
int local_2c;
sVar2 = strlen(param_1);
if (*(int *)(this + 0x1d8) == *(int *)(this + 0x1dc)) {
if (*(int *)(this + 0x1dc) == 0) {
*(int4 *)(this + 0x1dc) = 1;
}
iVar8 = *(int *)(this + 0x1dc) << 1;
*(int *)(this + 0x1dc) = iVar8;
iVar1 = *(int *)(this + 0x1d8);
lVar3 = lefMalloc((long)iVar8 << 3);
lVar4 = lefMalloc((long)iVar8 << 3);
lVar5 = lefMalloc((long)iVar8 << 3);
lVar6 = lefMalloc((long)iVar8);
for (local_2c = 0; local_2c < iVar1; local_2c = local_2c + 1) {
*(int8 *)(lVar3 + (long)local_2c * 8) =
*(int8 *)(*(long *)(this + 0x1e0) + (long)local_2c * 8);
*(int8 *)(lVar4 + (long)local_2c * 8) =
*(int8 *)(*(long *)(this + 0x1e8) + (long)local_2c * 8);
*(int8 *)(lVar5 + (long)local_2c * 8) =
*(int8 *)(*(long *)(this + 0x1f0) + (long)local_2c * 8);
*(int1 *)(lVar6 + local_2c) = *(int1 *)(*(long *)(this + 0x1f8) + (long)local_2c);
}
lefFree(*(void **)(this + 0x1e0));
lefFree(*(void **)(this + 0x1e8));
lefFree(*(void **)(this + 0x1f0));
lefFree(*(void **)(this + 0x1f8));
*(long *)(this + 0x1e0) = lVar3;
*(long *)(this + 0x1e8) = lVar4;
*(long *)(this + 0x1f0) = lVar5;
*(long *)(this + 0x1f8) = lVar6;
}
uVar7 = lefMalloc((long)((int)sVar2 + 1));
*(int8 *)(*(long *)(this + 0x1e0) + (long)*(int *)(this + 0x1d8) * 8) = uVar7;
strcpy(*(char **)(*(long *)(this + 0x1e0) + (long)*(int *)(this + 0x1d8) * 8),param_1);
sVar2 = strlen(param_3);
uVar7 = lefMalloc((long)((int)sVar2 + 1));
*(int8 *)(*(long *)(this + 0x1e8) + (long)*(int *)(this + 0x1d8) * 8) = uVar7;
strcpy(*(char **)(*(long *)(this + 0x1e8) + (long)*(int *)(this + 0x1d8) * 8),param_3);
*(double *)(*(long *)(this + 0x1f0) + (long)*(int *)(this + 0x1d8) * 8) = param_2;
*(char *)(*(long *)(this + 0x1f8) + (long)*(int *)(this + 0x1d8)) = param_4;
*(int *)(this + 0x1d8) = *(int *)(this + 0x1d8) + 1;
return;
}
| |
51,299 | LefDefParser::lefiViaRule::addNumProp(char const*, double, char const*, char) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiViaRule.cpp | void
lefiViaRule::addNumProp(const char *name,
const double d,
const char *value,
const char type)
{
int len = strlen(name) + 1;
if (numProps_ == propsAllocated_) {
int i;
int max;
int lim;
char **nn;
char **nv;
double *nd;
char *nt;
if (propsAllocated_ == 0)
propsAllocated_ = 1; // initialize propsAllocated_
max = propsAllocated_ *= 2;
lim = numProps_;
nn = (char**) lefMalloc(sizeof(char*) * max);
nv = (char**) lefMalloc(sizeof(char*) * max);
nd = (double*) lefMalloc(sizeof(double) * max);
nt = (char*) lefMalloc(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];
}
lefFree((char*) (names_));
lefFree((char*) (values_));
lefFree((char*) (dvalues_));
lefFree((char*) (types_));
names_ = nn;
values_ = nv;
dvalues_ = nd;
types_ = nt;
}
names_[numProps_] = (char*) lefMalloc(sizeof(char) * len);
strcpy(names_[numProps_], name);
len = strlen(value) + 1;
values_[numProps_] = (char*) lefMalloc(sizeof(char) * len);
strcpy(values_[numProps_], value);
dvalues_[numProps_] = d;
types_[numProps_] = type;
numProps_ += 1;
} | O3 | cpp | LefDefParser::lefiViaRule::addNumProp(char const*, double, char const*, char):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movsd %xmm0, 0x20(%rsp)
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20d0
movl 0x1d8(%r14), %r13d
cmpl 0x1dc(%r14), %r13d
jne 0x21c2a
movq %rax, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movl %ebx, 0x4(%rsp)
cmpl $0x2, %r13d
movl $0x1, %eax
cmovael %r13d, %eax
addl %eax, %eax
movl %eax, 0x1dc(%r14)
movslq %eax, %r12
leaq (,%r12,8), %r15
movq %r15, %rdi
callq 0x24985
movq %rax, %rbp
movq %r15, %rdi
callq 0x24985
movq %rax, %rbx
movq %r15, %rdi
callq 0x24985
movq %rax, %r15
movq %r12, %rdi
callq 0x24985
movq %rax, %r12
testl %r13d, %r13d
jle 0x21bcb
xorl %eax, %eax
movq 0x1e0(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, (%rbp,%rax,8)
movq 0x1e8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, (%rbx,%rax,8)
movq 0x1f0(%r14), %rcx
movsd (%rcx,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
movq 0x1f8(%r14), %rcx
movb (%rcx,%rax), %cl
movb %cl, (%r12,%rax)
incq %rax
cmpq %rax, %r13
jne 0x21b84
movq 0x1e0(%r14), %rdi
callq 0x26040
movq 0x1e8(%r14), %rdi
callq 0x26040
movq 0x1f0(%r14), %rdi
callq 0x26040
movq 0x1f8(%r14), %rdi
callq 0x26040
movq %rbp, 0x1e0(%r14)
movq %rbx, 0x1e8(%r14)
movq %r15, 0x1f0(%r14)
movq %r12, 0x1f8(%r14)
movl 0x4(%rsp), %ebx
movq 0x18(%rsp), %r15
movq 0x10(%rsp), %r12
movq 0x8(%rsp), %rax
incl %eax
movslq %eax, %rdi
callq 0x24985
movq 0x1e0(%r14), %rcx
movslq 0x1d8(%r14), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x1e0(%r14), %rax
movq (%rax,%rdx,8), %rdi
movq %r12, %rsi
callq 0x21b0
movq %r15, %rdi
callq 0x20d0
incl %eax
movslq %eax, %rdi
callq 0x24985
movq 0x1e8(%r14), %rcx
movslq 0x1d8(%r14), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x1e8(%r14), %rax
movq (%rax,%rdx,8), %rdi
movq %r15, %rsi
callq 0x21b0
movq 0x1f0(%r14), %rax
movslq 0x1d8(%r14), %rcx
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x1f8(%r14), %rax
movb %bl, (%rax,%rcx)
incl 0x1d8(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN12LefDefParser11lefiViaRule10addNumPropEPKcdS2_c:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebx, ecx
mov r15, rdx
movsd [rsp+58h+var_38], xmm0
mov r12, rsi
mov r14, rdi
mov rdi, rsi
call _strlen
mov r13d, [r14+1D8h]
cmp r13d, [r14+1DCh]
jnz loc_21C2A
mov [rsp+58h+var_50], rax
mov [rsp+58h+var_48], r12
mov [rsp+58h+var_40], r15
mov [rsp+58h+var_54], ebx
cmp r13d, 2
mov eax, 1
cmovnb eax, r13d
add eax, eax
mov [r14+1DCh], eax
movsxd r12, eax
lea r15, ds:0[r12*8]
mov rdi, r15; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rbp, rax
mov rdi, r15; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rbx, rax
mov rdi, r15; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r15, rax
mov rdi, r12; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r12, rax
test r13d, r13d
jle short loc_21BCB
xor eax, eax
loc_21B84:
mov rcx, [r14+1E0h]
mov rcx, [rcx+rax*8]
mov [rbp+rax*8+0], rcx
mov rcx, [r14+1E8h]
mov rcx, [rcx+rax*8]
mov [rbx+rax*8], rcx
mov rcx, [r14+1F0h]
movsd xmm0, qword ptr [rcx+rax*8]
movsd qword ptr [r15+rax*8], xmm0
mov rcx, [r14+1F8h]
mov cl, [rcx+rax]
mov [r12+rax], cl
inc rax
cmp r13, rax
jnz short loc_21B84
loc_21BCB:
mov rdi, [r14+1E0h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rdi, [r14+1E8h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rdi, [r14+1F0h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rdi, [r14+1F8h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov [r14+1E0h], rbp
mov [r14+1E8h], rbx
mov [r14+1F0h], r15
mov [r14+1F8h], r12
mov ebx, [rsp+58h+var_54]
mov r15, [rsp+58h+var_40]
mov r12, [rsp+58h+var_48]
mov rax, [rsp+58h+var_50]
loc_21C2A:
inc eax
movsxd rdi, eax; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rcx, [r14+1E0h]
movsxd rdx, dword ptr [r14+1D8h]
mov [rcx+rdx*8], rax
mov rax, [r14+1E0h]
mov rdi, [rax+rdx*8]
mov rsi, r12; unsigned __int64
call _strcpy
mov rdi, r15
call _strlen
inc eax
movsxd rdi, eax; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rcx, [r14+1E8h]
movsxd rdx, dword ptr [r14+1D8h]
mov [rcx+rdx*8], rax
mov rax, [r14+1E8h]
mov rdi, [rax+rdx*8]
mov rsi, r15
call _strcpy
mov rax, [r14+1F0h]
movsxd rcx, dword ptr [r14+1D8h]
movsd xmm0, [rsp+58h+var_38]
movsd qword ptr [rax+rcx*8], xmm0
mov rax, [r14+1F8h]
mov [rax+rcx], bl
inc dword ptr [r14+1D8h]
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long LefDefParser::lefiViaRule::addNumProp(
LefDefParser::lefiViaRule *this,
char *a2,
double a3,
const char *a4,
char a5)
{
const char *v7; // r12
int v8; // eax
long long v9; // r13
int v10; // eax
int v11; // eax
LefDefParser *v12; // r12
LefDefParser *v13; // r15
long long v14; // rbp
long long v15; // rbx
long long v16; // r15
long long v17; // r12
long long i; // rax
long long v19; // rax
long long v20; // rdx
int v21; // eax
long long v22; // rax
long long v23; // rdx
long long v24; // rcx
long long result; // rax
char v26; // [rsp+4h] [rbp-54h]
int v27; // [rsp+8h] [rbp-50h]
const char *v28; // [rsp+18h] [rbp-40h]
v7 = a2;
v8 = strlen(a2);
v9 = *((unsigned int *)this + 118);
if ( (_DWORD)v9 == *((_DWORD *)this + 119) )
{
v27 = v8;
v28 = a4;
v26 = a5;
v10 = 1;
if ( (unsigned int)v9 >= 2 )
v10 = *((_DWORD *)this + 118);
v11 = 2 * v10;
*((_DWORD *)this + 119) = v11;
v12 = (LefDefParser *)v11;
v13 = (LefDefParser *)(8LL * v11);
v14 = LefDefParser::lefMalloc(v13, (unsigned long long)a2);
v15 = LefDefParser::lefMalloc(v13, (unsigned long long)a2);
v16 = LefDefParser::lefMalloc(v13, (unsigned long long)a2);
v17 = LefDefParser::lefMalloc(v12, (unsigned long long)a2);
if ( (int)v9 > 0 )
{
for ( i = 0LL; i != v9; ++i )
{
*(_QWORD *)(v14 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 60) + 8 * i);
*(_QWORD *)(v15 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 61) + 8 * i);
*(_QWORD *)(v16 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 62) + 8 * i);
*(_BYTE *)(v17 + i) = *(_BYTE *)(*((_QWORD *)this + 63) + i);
}
}
LefDefParser::lefFree(*((LefDefParser **)this + 60), a2);
LefDefParser::lefFree(*((LefDefParser **)this + 61), a2);
LefDefParser::lefFree(*((LefDefParser **)this + 62), a2);
LefDefParser::lefFree(*((LefDefParser **)this + 63), a2);
*((_QWORD *)this + 60) = v14;
*((_QWORD *)this + 61) = v15;
*((_QWORD *)this + 62) = v16;
*((_QWORD *)this + 63) = v17;
a5 = v26;
a4 = v28;
v7 = a2;
v8 = v27;
}
v19 = LefDefParser::lefMalloc((LefDefParser *)(v8 + 1), (unsigned long long)a2);
v20 = *((int *)this + 118);
*(_QWORD *)(*((_QWORD *)this + 60) + 8 * v20) = v19;
strcpy(*(_QWORD *)(*((_QWORD *)this + 60) + 8 * v20), v7);
v21 = strlen(a4);
v22 = LefDefParser::lefMalloc((LefDefParser *)(v21 + 1), (unsigned long long)v7);
v23 = *((int *)this + 118);
*(_QWORD *)(*((_QWORD *)this + 61) + 8 * v23) = v22;
strcpy(*(_QWORD *)(*((_QWORD *)this + 61) + 8 * v23), a4);
v24 = *((int *)this + 118);
*(double *)(*((_QWORD *)this + 62) + 8 * v24) = a3;
result = *((_QWORD *)this + 63);
*(_BYTE *)(result + v24) = a5;
++*((_DWORD *)this + 118);
return result;
}
| addNumProp:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBX,ECX
MOV R15,RDX
MOVSD qword ptr [RSP + 0x20],XMM0
MOV R12,RSI
MOV R14,RDI
MOV RDI,RSI
CALL 0x001020d0
MOV R13D,dword ptr [R14 + 0x1d8]
CMP R13D,dword ptr [R14 + 0x1dc]
JNZ 0x00121c2a
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],R12
MOV qword ptr [RSP + 0x18],R15
MOV dword ptr [RSP + 0x4],EBX
CMP R13D,0x2
MOV EAX,0x1
CMOVNC EAX,R13D
ADD EAX,EAX
MOV dword ptr [R14 + 0x1dc],EAX
MOVSXD R12,EAX
LEA R15,[R12*0x8]
MOV RDI,R15
CALL 0x00124985
MOV RBP,RAX
MOV RDI,R15
CALL 0x00124985
MOV RBX,RAX
MOV RDI,R15
CALL 0x00124985
MOV R15,RAX
MOV RDI,R12
CALL 0x00124985
MOV R12,RAX
TEST R13D,R13D
JLE 0x00121bcb
XOR EAX,EAX
LAB_00121b84:
MOV RCX,qword ptr [R14 + 0x1e0]
MOV RCX,qword ptr [RCX + RAX*0x8]
MOV qword ptr [RBP + RAX*0x8],RCX
MOV RCX,qword ptr [R14 + 0x1e8]
MOV RCX,qword ptr [RCX + RAX*0x8]
MOV qword ptr [RBX + RAX*0x8],RCX
MOV RCX,qword ptr [R14 + 0x1f0]
MOVSD XMM0,qword ptr [RCX + RAX*0x8]
MOVSD qword ptr [R15 + RAX*0x8],XMM0
MOV RCX,qword ptr [R14 + 0x1f8]
MOV CL,byte ptr [RCX + RAX*0x1]
MOV byte ptr [R12 + RAX*0x1],CL
INC RAX
CMP R13,RAX
JNZ 0x00121b84
LAB_00121bcb:
MOV RDI,qword ptr [R14 + 0x1e0]
CALL 0x00126040
MOV RDI,qword ptr [R14 + 0x1e8]
CALL 0x00126040
MOV RDI,qword ptr [R14 + 0x1f0]
CALL 0x00126040
MOV RDI,qword ptr [R14 + 0x1f8]
CALL 0x00126040
MOV qword ptr [R14 + 0x1e0],RBP
MOV qword ptr [R14 + 0x1e8],RBX
MOV qword ptr [R14 + 0x1f0],R15
MOV qword ptr [R14 + 0x1f8],R12
MOV EBX,dword ptr [RSP + 0x4]
MOV R15,qword ptr [RSP + 0x18]
MOV R12,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x8]
LAB_00121c2a:
INC EAX
MOVSXD RDI,EAX
CALL 0x00124985
MOV RCX,qword ptr [R14 + 0x1e0]
MOVSXD RDX,dword ptr [R14 + 0x1d8]
MOV qword ptr [RCX + RDX*0x8],RAX
MOV RAX,qword ptr [R14 + 0x1e0]
MOV RDI,qword ptr [RAX + RDX*0x8]
MOV RSI,R12
CALL 0x001021b0
MOV RDI,R15
CALL 0x001020d0
INC EAX
MOVSXD RDI,EAX
CALL 0x00124985
MOV RCX,qword ptr [R14 + 0x1e8]
MOVSXD RDX,dword ptr [R14 + 0x1d8]
MOV qword ptr [RCX + RDX*0x8],RAX
MOV RAX,qword ptr [R14 + 0x1e8]
MOV RDI,qword ptr [RAX + RDX*0x8]
MOV RSI,R15
CALL 0x001021b0
MOV RAX,qword ptr [R14 + 0x1f0]
MOVSXD RCX,dword ptr [R14 + 0x1d8]
MOVSD XMM0,qword ptr [RSP + 0x20]
MOVSD qword ptr [RAX + RCX*0x8],XMM0
MOV RAX,qword ptr [R14 + 0x1f8]
MOV byte ptr [RAX + RCX*0x1],BL
INC dword ptr [R14 + 0x1d8]
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* LefDefParser::lefiViaRule::addNumProp(char const*, double, char const*, char) */
void __thiscall
LefDefParser::lefiViaRule::addNumProp
(lefiViaRule *this,char *param_1,double param_2,char *param_3,char param_4)
{
LefDefParser *this_00;
uint uVar1;
int iVar2;
uint uVar3;
size_t sVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
ulong uVar9;
int8 uVar10;
char *pcVar11;
pcVar11 = param_1;
sVar4 = strlen(param_1);
uVar1 = *(uint *)(this + 0x1d8);
if (uVar1 == *(uint *)(this + 0x1dc)) {
uVar3 = 1;
if (1 < uVar1) {
uVar3 = uVar1;
}
iVar2 = uVar3 * 2;
*(int *)(this + 0x1dc) = iVar2;
this_00 = (LefDefParser *)((long)iVar2 * 8);
lVar5 = lefMalloc(this_00,(ulong)pcVar11);
lVar6 = lefMalloc(this_00,(ulong)pcVar11);
lVar7 = lefMalloc(this_00,(ulong)pcVar11);
lVar8 = lefMalloc((LefDefParser *)(long)iVar2,(ulong)pcVar11);
if (0 < (int)uVar1) {
uVar9 = 0;
do {
*(int8 *)(lVar5 + uVar9 * 8) = *(int8 *)(*(long *)(this + 0x1e0) + uVar9 * 8);
*(int8 *)(lVar6 + uVar9 * 8) = *(int8 *)(*(long *)(this + 0x1e8) + uVar9 * 8);
*(int8 *)(lVar7 + uVar9 * 8) = *(int8 *)(*(long *)(this + 0x1f0) + uVar9 * 8);
*(int1 *)(lVar8 + uVar9) = *(int1 *)(*(long *)(this + 0x1f8) + uVar9);
uVar9 = uVar9 + 1;
} while (uVar1 != uVar9);
}
lefFree(*(void **)(this + 0x1e0));
lefFree(*(void **)(this + 0x1e8));
lefFree(*(void **)(this + 0x1f0));
lefFree(*(void **)(this + 0x1f8));
*(long *)(this + 0x1e0) = lVar5;
*(long *)(this + 0x1e8) = lVar6;
*(long *)(this + 0x1f0) = lVar7;
*(long *)(this + 0x1f8) = lVar8;
}
uVar10 = lefMalloc((LefDefParser *)(long)((int)sVar4 + 1),(ulong)pcVar11);
iVar2 = *(int *)(this + 0x1d8);
*(int8 *)(*(long *)(this + 0x1e0) + (long)iVar2 * 8) = uVar10;
strcpy(*(char **)(*(long *)(this + 0x1e0) + (long)iVar2 * 8),param_1);
sVar4 = strlen(param_3);
uVar10 = lefMalloc((LefDefParser *)(long)((int)sVar4 + 1),(ulong)param_1);
iVar2 = *(int *)(this + 0x1d8);
*(int8 *)(*(long *)(this + 0x1e8) + (long)iVar2 * 8) = uVar10;
strcpy(*(char **)(*(long *)(this + 0x1e8) + (long)iVar2 * 8),param_3);
iVar2 = *(int *)(this + 0x1d8);
*(double *)(*(long *)(this + 0x1f0) + (long)iVar2 * 8) = param_2;
*(char *)(*(long *)(this + 0x1f8) + (long)iVar2) = param_4;
*(int *)(this + 0x1d8) = *(int *)(this + 0x1d8) + 1;
return;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.