name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
emulator_read_ext_ram_from_file | Result emulator_read_ext_ram_from_file(Emulator* e, const char* filename) {
if (EXT_RAM.battery_type != BATTERY_TYPE_WITH_BATTERY)
return OK;
Result result = ERROR;
FileData file_data;
ZERO_MEMORY(file_data);
CHECK(SUCCESS(file_read(filename, &file_data)));
CHECK(SUCCESS(emulator_read_ext_ram(e, &file_data)));
result = OK;
error:
file_data_delete(&file_data);
return result;
} | pushq %rbp
pushq %rbx
subq $0x18, %rsp
xorl %ebp, %ebp
cmpl $0x1, 0x270d0(%rdi)
jne 0x84bae
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq %rsi, %rdi
movq %rax, %rsi
callq 0x8160e
testl %eax, %eax
je 0x84b99
pushq $0x1
popq %rbp
jmp 0x84ba6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x84aa9
movl %eax, %ebp
movq %rsp, %rdi
callq 0x81921
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
| /binji[P]binjgb/src/emulator.c |
read_u8_pair | static u8 read_u8_pair(Emulator* e, MemoryTypeAddressPair pair, Bool raw) {
switch (pair.type) {
/* Take advantage of the fact that MEMORY_MAP_ROM9 is 0, and ROM1 is 1 when
* indexing into rom_base. */
case MEMORY_MAP_ROM0:
case MEMORY_MAP_ROM1: {
u32 rom_addr = MMAP_STATE.rom_base[pair.type] | pair.addr;
assert(rom_addr < e->cart_info->size);
u8 value = e->cart_info->data[rom_addr];
if (!raw) {
HOOK(read_rom_ib, rom_addr, value);
}
return value;
}
case MEMORY_MAP_VRAM:
return read_vram(e, pair.addr);
case MEMORY_MAP_EXT_RAM:
return e->memory_map.read_ext_ram(e, pair.addr);
case MEMORY_MAP_WORK_RAM0:
return WRAM.data[pair.addr];
case MEMORY_MAP_WORK_RAM1:
return WRAM.data[WRAM.offset + pair.addr];
case MEMORY_MAP_OAM:
return read_oam(e, pair.addr);
case MEMORY_MAP_UNUSED:
return INVALID_READ_BYTE;
case MEMORY_MAP_IO: {
u8 value = read_io(e, pair.addr);
HOOK(read_io_asb, pair.addr, get_io_reg_string(pair.addr), value);
return value;
}
case MEMORY_MAP_APU:
return read_apu(e, pair.addr);
case MEMORY_MAP_WAVE_RAM:
return read_wave_ram(e, pair.addr);
case MEMORY_MAP_HIGH_RAM:
return HRAM[pair.addr];
default:
UNREACHABLE("invalid address: %u 0x%04x.\n", pair.type, pair.addr);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rsi, %r12
shrq $0x20, %r12
cmpl $0xb, %r14d
ja 0x8b853
movq %rdi, %rbx
movb $-0x1, %bpl
movl %r14d, %eax
leaq 0x2a841(%rip), %rcx # 0xb5854
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
movzwl %r12w, %r15d
jmpq *%rax
movl %r14d, %eax
movzwl %r12w, %edi
orl 0x3070(%rbx,%rax,4), %edi
movq 0x3040(%rbx), %rax
cmpq %rdi, 0x10(%rax)
jbe 0x8b834
movq 0x8(%rax), %rax
movb (%rax,%rdi), %bpl
testl %edx, %edx
jne 0x8b829
callq 0x8ba1d
jmp 0x8b829
movzwl 0x2f0d8(%rbx), %eax
movzwl %r12w, %ecx
addq %rax, %rcx
movb 0x270d8(%rbx,%rcx), %bpl
jmp 0x8b829
movzwl %r12w, %eax
movb 0x33b78(%rbx,%rax), %bpl
jmp 0x8b829
movzwl %r12w, %eax
movb 0x270d8(%rbx,%rax), %bpl
jmp 0x8b829
movq %rbx, %rdi
callq 0x81f1b
cmpw $0x16, %r12w
ja 0x8b829
leaq 0x2a7d4(%rip), %rax # 0xb5884
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb 0x336b0(%rbx), %al
movb 0x336b4(%rbx), %bpl
shlb $0x4, %al
movb 0x336b8(%rbx), %cl
andb $0x7, %cl
orb %al, %cl
shlb $0x3, %bpl
andb $0x8, %bpl
orb %cl, %bpl
orb $-0x80, %bpl
jmp 0x8b829
movq %rbx, %rdi
callq 0x896e3
movl 0x3387c(%rbx), %eax
cmpl $0x3, %eax
je 0x8b111
cmpl $0x2, %eax
jne 0x8b281
cmpl $0x4, 0x33a68(%rbx)
jne 0x8b281
movzwl %r12w, %edx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8bb32
jmp 0x8b829
movq 0x3048(%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rbx, %rdi
callq 0x896e3
cmpl $0x0, 0x33864(%rbx)
jne 0x8b15e
movl 0x3387c(%rbx), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x8b2ab
movzwl %r12w, %edx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8bbff
jmp 0x8b829
movq %rbx, %rdi
callq 0x81f1b
cmpl $0x0, 0x337cc(%rbx)
je 0x8b228
cmpl $0x0, 0x33c10(%rbx)
jne 0x8b1a3
movq 0x33bf8(%rbx), %rax
cmpq 0x336e0(%rbx), %rax
jne 0x8b2e0
movzbl 0x336f0(%rbx), %eax
shrl %eax
movb 0x336cd(%rbx,%rax), %bpl
movzwl %r12w, %edx
movzbl %bpl, %ecx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8bdb2
jmp 0x8b829
movzwl %r12w, %r14d
movb $-0x1, %bpl
leal -0x40(%r15), %eax
cmpl $0x30, %eax
ja 0x8b239
leaq 0x2a73e(%rip), %rcx # 0xb5920
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leal -0x47(%r14), %eax
shlq $0x4, %rax
movl 0x338a0(%rbx,%rax), %ecx
shll $0x6, %ecx
movl 0x3389c(%rbx,%rax), %edx
shll $0x4, %edx
andl $0x30, %edx
orl %ecx, %edx
movl 0x33894(%rbx,%rax), %ebp
movl 0x33898(%rbx,%rax), %eax
andl $0x3, %eax
leal (%rdx,%rax,4), %eax
andl $0x3, %ebp
jmp 0x8b65e
movzwl %r12w, %eax
movb 0x336cd(%rbx,%rax), %bpl
jmp 0x8b829
cmpl $0xf, %r15d
ja 0x8b540
movl %r15d, %eax
leaq 0x2a693(%rip), %rcx # 0xb58e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
xorl %esi, %esi
callq 0x85e7d
movb 0x2f428(%rbx), %bpl
movq %rbx, %rdi
callq 0x85ec8
andb $0xf, %al
shlb $0x4, %bpl
orb %al, %bpl
orb $-0x40, %bpl
jmp 0x8b7ef
cmpw $0x2000, %r12w # imm = 0x2000
jae 0x8b87a
andl $0x1fff, %r12d # imm = 0x1FFF
movzwl 0x70c4(%rbx), %eax
addq %r12, %rax
movb 0x30c4(%rbx,%rax), %bpl
jmp 0x8b829
shrq $0x22, %r14
movzbl %r14b, %eax
imulq $0x14, %rax, %rax
addq %rbx, %rax
addq $0x2f0e8, %rax # imm = 0x2F0E8
andl $0x3, %r12d
leaq 0x2a719(%rip), %rcx # 0xb59e4
movslq (%rcx,%r12,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movb (%rax), %bpl
addb $0x10, %bpl
jmp 0x8b829
movzwl %r12w, %edx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8be7f
jmp 0x8b829
cmpl $0x0, 0x33c10(%rbx)
je 0x8b7ef
leaq 0x3398c(%rbx), %rax
leaq 0x338c4(%rbx), %rcx
cmpw $0x68, %r12w
cmoveq %rcx, %rax
movb 0xc0(%rax), %cl
movb 0xc4(%rax), %bpl
andb $0x3f, %cl
shlb $0x7, %bpl
orb %cl, %bpl
orb $0x40, %bpl
jmp 0x8b7ef
cmpl $0x0, 0x33c10(%rbx)
je 0x8b7ef
leaq 0x3398c(%rbx), %rax
leaq 0x338c4(%rbx), %rcx
cmpw $0x69, %r12w
cmoveq %rcx, %rax
movzbl 0xc0(%rax), %ecx
movb 0x80(%rax,%rcx), %bpl
jmp 0x8b7ef
movl 0x336a8(%rbx), %eax
shll $0x7, %eax
movzbl 0x33681(%rbx), %ecx
shll $0x4, %ecx
andl $0x70, %ecx
orl %eax, %ecx
movl 0x336a4(%rbx), %eax
andl $0x1, %eax
leal (%rcx,%rax,8), %ebp
movb 0x33680(%rbx), %al
andb $0x7, %al
orb %al, %bpl
jmp 0x8b829
addq $0x337d4, %rbx # imm = 0x337D4
jmp 0x8b3c8
movb 0x33804(%rbx), %bpl
jmp 0x8b500
addq $0x33714, %rbx # imm = 0x33714
jmp 0x8b3c8
addq $0x33754, %rbx # imm = 0x33754
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8bd99
movb 0x33700(%rbx), %al
movb 0x33704(%rbx), %bpl
shlb $0x4, %al
movb 0x33708(%rbx), %cl
andb $0x7, %cl
shlb $0x3, %bpl
andb $0x8, %bpl
orb %al, %bpl
orb %cl, %bpl
jmp 0x8b829
movb 0x33714(%rbx), %bpl
jmp 0x8b4ec
movb 0x33784(%rbx), %bpl
jmp 0x8b500
movb 0x337c8(%rbx), %bpl
shlb $0x7, %bpl
orb $0x7f, %bpl
jmp 0x8b829
movl 0x336a0(%rbx), %eax
shll $0x7, %eax
movzbl %al, %eax
movl 0x33698(%rbx), %ecx
shll $0x6, %ecx
andl $0x40, %ecx
orl %eax, %ecx
movl 0x33690(%rbx), %eax
shll $0x5, %eax
andl $0x20, %eax
orl %ecx, %eax
movl 0x33684(%rbx), %ebp
movl 0x33688(%rbx), %ecx
shll $0x4, %ecx
andl $0x10, %ecx
orl %eax, %ecx
movl 0x3369c(%rbx), %eax
andl $0x1, %eax
leal (%rcx,%rax,8), %eax
movl 0x33694(%rbx), %ecx
andl $0x1, %ecx
leal (%rax,%rcx,4), %eax
movl 0x3368c(%rbx), %ecx
addl %ecx, %ecx
andl $0x2, %ecx
andl $0x1, %ebp
orl %ecx, %ebp
orl %eax, %ebp
jmp 0x8b829
movl 0x336ac(%rbx), %eax
movl 0x3374c(%rbx), %ebp
shll $0x7, %eax
movl 0x3380c(%rbx), %ecx
andl $0x1, %ecx
leal (%rax,%rcx,8), %eax
movl 0x337cc(%rbx), %ecx
andl $0x1, %ecx
leal (%rax,%rcx,4), %eax
movl 0x3378c(%rbx), %ecx
andl $0x1, %ecx
leal (%rax,%rcx,2), %eax
andl $0x1, %ebp
orl %eax, %ebp
orb $0x70, %bpl
jmp 0x8b829
movb 0x33744(%rbx), %bpl
jmp 0x8b500
movb 0x33754(%rbx), %bpl
shlb $0x6, %bpl
orb $0x3f, %bpl
jmp 0x8b829
movb 0x337c4(%rbx), %bpl
shlb $0x6, %bpl
orb $-0x41, %bpl
jmp 0x8b829
movb 0x336c8(%rbx), %bpl
shlb $0x5, %bpl
orb $-0x61, %bpl
jmp 0x8b829
movb 0x2(%rax), %bpl
jmp 0x8b829
movb 0x3(%rax), %bpl
jmp 0x8b829
movb 0x1(%rax), %bpl
addb $0x8, %bpl
jmp 0x8b829
cmpl $0xff, %r15d
jne 0x8b555
movb 0x2f0e0(%rbx), %bpl
jmp 0x8b7ef
leaq 0x2cfd5(%rip), %rcx # 0xb8531
movq %rcx, %rax
cmpl $0xff, %r14d
ja 0x8b577
movzwl %r12w, %eax
leaq 0x4ffad(%rip), %rdx # 0xdb520
movq (%rdx,%rax,8), %rax
testq %rax, %rax
cmovneq %rax, %rcx
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x8bccc
jmp 0x8b7ef
cmpl $0x0, 0x33c10(%rbx)
je 0x8b7ef
movl 0x33b70(%rbx), %eax
movl 0x33b74(%rbx), %ebp
jmp 0x8b787
movb 0x3388f(%rbx), %bpl
jmp 0x8b7ef
movb 0x3388c(%rbx), %bpl
jmp 0x8b7ef
movq %rbx, %rdi
callq 0x896e3
movb 0x3388e(%rbx), %bpl
jmp 0x8b7ef
movb 0x3388d(%rbx), %bpl
jmp 0x8b7ef
movdqu 0x33838(%rbx), %xmm0
movdqa 0x2973a(%rip), %xmm1 # 0xb4d30
pshufd $0xf5, %xmm0, %xmm2 # xmm2 = xmm0[1,1,3,3]
pmuludq %xmm1, %xmm0
pshufd $0xe8, %xmm0, %xmm0 # xmm0 = xmm0[0,2,2,3]
pshufd $0xf5, %xmm1, %xmm3 # xmm3 = xmm1[1,1,3,3]
pmuludq %xmm2, %xmm3
pshufd $0xe8, %xmm3, %xmm2 # xmm2 = xmm3[0,2,2,3]
punpckldq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
pand %xmm1, %xmm0
movl 0x33848(%rbx), %eax
andl $0x1, %eax
movl 0x3384c(%rbx), %ecx
andl $0x1, %ecx
movl 0x33850(%rbx), %edx
andl $0x1, %edx
addl %edx, %edx
movl 0x33854(%rbx), %esi
andl $0x1, %esi
pshufd $0xee, %xmm0, %xmm1 # xmm1 = xmm0[2,3,2,3]
por %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0 # xmm0 = xmm1[1,1,1,1]
por %xmm1, %xmm0
movd %xmm0, %edi
leal (%rdi,%rax,8), %eax
leal (%rdx,%rcx,4), %ebp
orl %esi, %ebp
orl %eax, %ebp
jmp 0x8b7ef
movq %rbx, %rdi
callq 0x896e3
movl 0x33858(%rbx), %eax
movl 0x33860(%rbx), %ecx
shll $0x6, %eax
andl $0x40, %eax
shll $0x5, %ecx
andl $0x20, %ecx
orl %eax, %ecx
movl 0x33868(%rbx), %eax
shll $0x4, %eax
andl $0x10, %eax
orl %ecx, %eax
movl 0x33870(%rbx), %ecx
andl $0x1, %ecx
leal (%rax,%rcx,8), %eax
movl 0x33878(%rbx), %ecx
andl $0x1, %ecx
leal (%rax,%rcx,4), %eax
movl 0x3387c(%rbx), %ebp
andl $0x3, %ebp
orl %eax, %ebp
orb $-0x80, %bpl
jmp 0x8b7ef
cmpl $0x0, 0x33c10(%rbx)
je 0x8b7ef
movb 0x2f0da(%rbx), %bpl
jmp 0x8b7a7
movb 0x33890(%rbx), %bpl
jmp 0x8b7ef
movb 0x33891(%rbx), %bpl
jmp 0x8b7ef
cmpl $0x0, 0x33c10(%rbx)
je 0x8b7ef
movl 0x33658(%rbx), %eax
shll $0x6, %eax
movl 0x33650(%rbx), %ebp
movl 0x33654(%rbx), %ecx
andl $0x1, %ecx
leal (%rax,%rcx,2), %eax
andl $0x1, %ebp
orl %eax, %ebp
orb $0x3c, %bpl
jmp 0x8b7ef
cmpl $0x0, 0x33c10(%rbx)
je 0x8b7ef
movb 0x33b6c(%rbx), %bpl
jmp 0x8b7ef
cmpl $0x0, 0x33c10(%rbx)
je 0x8b7ef
movb 0x70c6(%rbx), %bpl
orb $-0x2, %bpl
jmp 0x8b7ef
movq %rbx, %rdi
callq 0x89ca2
movb 0x2f0e1(%rbx), %bpl
orb $-0x20, %bpl
jmp 0x8b7ef
movq %rbx, %rdi
callq 0x895f1
movl 0x33640(%rbx), %ebp
movl 0x33644(%rbx), %eax
shll $0x7, %eax
andl $0x1, %ebp
orl %eax, %ebp
orb $0x7e, %bpl
jmp 0x8b7ef
movl 0x33670(%rbx), %eax
movl 0x3367c(%rbx), %ecx
andl $0x3, %eax
leal (%rax,%rcx,4), %ebp
orb $-0x8, %bpl
jmp 0x8b7ef
movq %rbx, %rdi
callq 0x895f1
movb 0x33648(%rbx), %bpl
jmp 0x8b7ef
movq %rbx, %rdi
callq 0x8951a
movb 0x3367a(%rbx), %bpl
jmp 0x8b7ef
movq %rbx, %rdi
callq 0x8951a
movb 0x33679(%rbx), %bpl
jmp 0x8b7ef
movq %rbx, %rdi
callq 0x8951a
movb 0x3367b(%rbx), %bpl
leaq 0x2cd3b(%rip), %rcx # 0xb8531
movq %rcx, %rax
cmpl $0xff, %r14d
ja 0x8b811
movzwl %r12w, %eax
leaq 0x4fd13(%rip), %rdx # 0xdb520
movq (%rdx,%rax,8), %rax
testq %rax, %rax
cmovneq %rax, %rcx
movzbl %bpl, %r8d
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x8ba2f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2caf4(%rip), %rdi # 0xb832f
leaq 0x2c422(%rip), %rsi # 0xb7c64
leaq 0x2cb04(%rip), %rcx # 0xb834d
movl $0x7a0, %edx # imm = 0x7A0
callq 0x24110
movq 0x51786(%rip), %rax # 0xdcfe0
movq (%rax), %rdi
movzwl %r12w, %ecx
leaq 0x2cb2b(%rip), %rsi # 0xb8393
movl %r14d, %edx
xorl %eax, %eax
callq 0x24160
pushq $0x1
popq %rdi
callq 0x243f0
leaq 0x2cb7f(%rip), %rdi # 0xb8400
leaq 0x2c3dc(%rip), %rsi # 0xb7c64
leaq 0x2cb86(%rip), %rcx # 0xb8415
movl $0x684, %edx # imm = 0x684
callq 0x24110
| /binji[P]binjgb/src/emulator.c |
write_audio_frame | static void write_audio_frame(Emulator* e, u32 gb_frames) {
int i, j;
AudioBuffer* buffer = &e->audio_buffer;
buffer->divisor += gb_frames;
buffer->freq_counter += buffer->frequency * gb_frames;
if (VALUE_WRAPPED(buffer->freq_counter, APU_TICKS_PER_SECOND)) {
for (i = 0; i < SOUND_OUTPUT_COUNT; ++i) {
u32 accumulator = 0;
for (j = 0; j < APU_CHANNEL_COUNT; ++j) {
if (!e->config.disable_sound[j]) {
accumulator += APU.channel[j].accumulator * APU.so_output[j][i];
}
}
accumulator *= (APU.so_volume[i] + 1) * 16; /* 4bit -> 8bit samples. */
accumulator /= ((SOUND_OUTPUT_MAX_VOLUME + 1) * APU_CHANNEL_COUNT);
*buffer->position++ = accumulator / buffer->divisor;
}
for (j = 0; j < APU_CHANNEL_COUNT; ++j) {
APU.channel[j].accumulator = 0;
}
buffer->divisor = 0;
}
assert(buffer->position <= buffer->end);
} | pushq %rax
addl %esi, 0x82428(%rdi)
imull 0x82420(%rdi), %esi
addl 0x82424(%rdi), %esi
movl %esi, %eax
subl $0x200000, %eax # imm = 0x200000
cmovbl %esi, %eax
movl %eax, 0x82424(%rdi)
jae 0x8ca65
movq 0x82440(%rdi), %rax
cmpq 0x82438(%rdi), %rax
ja 0x8cb04
popq %rax
retq
movl $0x33684, %ecx # imm = 0x33684
xorl %esi, %esi
cmpq $0x2, %rsi
je 0x8cae0
xorl %edx, %edx
movl $0xcdd4, %eax # imm = 0xCDD4
movq %rcx, %r8
movq %rdi, %r9
cmpq $0xce14, %rax # imm = 0xCE14
je 0x8caa7
cmpl $0x0, (%r9)
jne 0x8ca99
movl (%rdi,%r8), %r10d
imull (%rdi,%rax,4), %r10d
addl %r10d, %edx
addq $0x10, %rax
addq $0x4, %r9
addq $0x8, %r8
jmp 0x8ca7f
movzbl 0x33680(%rdi,%rsi), %eax
shll $0x4, %eax
addl $0x10, %eax
imull %edx, %eax
shrl $0x5, %eax
xorl %edx, %edx
divl 0x82428(%rdi)
movq 0x82440(%rdi), %rdx
leaq 0x1(%rdx), %r8
movq %r8, 0x82440(%rdi)
movb %al, (%rdx)
incq %rsi
addq $0x4, %rcx
jmp 0x8ca6c
xorl %eax, %eax
cmpq $0x100, %rax # imm = 0x100
je 0x8caf8
andl $0x0, 0x33750(%rdi,%rax)
addq $0x40, %rax
jmp 0x8cae2
andl $0x0, 0x82428(%rdi)
jmp 0x8ca4f
leaq 0x2bd6c(%rip), %rdi # 0xb8877
leaq 0x2b152(%rip), %rsi # 0xb7c64
leaq 0x2bd7e(%rip), %rcx # 0xb8897
movl $0xf36, %edx # imm = 0xF36
callq 0x24110
| /binji[P]binjgb/src/emulator.c |
update_square_wave | static void update_square_wave(Channel* channel, u32 total_frames) {
static u8 duty[WAVE_DUTY_COUNT][DUTY_CYCLE_COUNT] =
{[WAVE_DUTY_12_5] = {0, 0, 0, 0, 0, 0, 0, 1},
[WAVE_DUTY_25] = {1, 0, 0, 0, 0, 0, 0, 1},
[WAVE_DUTY_50] = {1, 0, 0, 0, 0, 1, 1, 1},
[WAVE_DUTY_75] = {0, 1, 1, 1, 1, 1, 1, 0}};
SquareWave* square = &channel->square_wave;
if (channel->status) {
while (total_frames) {
u32 frames = square->ticks / APU_TICKS;
u8 sample = CHANNELX_SAMPLE(channel, square->sample);
if (frames <= total_frames) {
square->ticks = square->period;
square->position = (square->position + 1) % DUTY_CYCLE_COUNT;
square->sample = duty[square->duty][square->position];
} else {
frames = total_frames;
square->ticks -= frames * APU_TICKS;
}
channel->accumulator += sample * frames;
total_frames -= frames;
}
}
} | testl %esi, %esi
je 0x8cf28
cmpl $0x0, 0x38(%rdi)
je 0x8cf28
pushq %rbx
movzbl 0x1d(%rdi), %eax
movl 0x10(%rdi), %edx
movb 0x4(%rdi), %r9b
movl 0x3c(%rdi), %ecx
leaq 0x2d4bf(%rip), %r8 # 0xba390
movl %edx, %r10d
shrl %r10d
cmpl %esi, %r10d
jbe 0x8cee8
subl %esi, %edx
subl %esi, %edx
movl %r9d, %r11d
movl %esi, %r10d
jmp 0x8cf08
movl (%rdi), %r11d
movl 0x8(%rdi), %edx
movb 0xc(%rdi), %bl
incb %bl
andb $0x7, %bl
movb %bl, 0xc(%rdi)
movzbl %bl, %ebx
leaq (%r8,%r11,8), %r11
movb (%rbx,%r11), %r11b
movb %r11b, 0x4(%rdi)
negb %r9b
movzbl %r9b, %r9d
andl %eax, %r9d
imull %r10d, %r9d
addl %r9d, %ecx
movl %r11d, %r9d
subl %r10d, %esi
jne 0x8ced1
movl %edx, 0x10(%rdi)
movl %ecx, 0x3c(%rdi)
popq %rbx
retq
| /binji[P]binjgb/src/emulator.c |
mbc3_read_ext_ram | static u8 mbc3_read_ext_ram(Emulator* e, MaskedAddress addr) {
if (!MMAP_STATE.ext_ram_enabled) {
return INVALID_READ_BYTE;
}
Mbc3* mbc3 = &MMAP_STATE.mbc3;
if (mbc3->rtc_reg <= 3) {
return gb_read_ext_ram(e, addr);
}
if (!mbc3->latched) {
return INVALID_READ_BYTE;
}
u8 result = INVALID_READ_BYTE;
switch (mbc3->rtc_reg) {
case 8: result = mbc3->sec; break;
case 9: result = mbc3->min; break;
case 10: result = mbc3->hour; break;
case 11: result = mbc3->day; break;
case 12:
result = PACK(mbc3->day_carry, MBC3_RTC_DAY_CARRY) |
PACK(mbc3->rtc_halt, MBC3_RTC_HALT) |
PACK((mbc3->day >> 8) & 1, MBC3_RTC_DAY_HI);
break;
}
return result;
} | movb $-0x1, %al
cmpl $0x0, 0x307c(%rdi)
je 0x8ef12
movzbl 0x3098(%rdi), %ecx
cmpl $0x3, %ecx
ja 0x8eeeb
movzwl %si, %esi
jmp 0x8eab9
cmpl $0x0, 0x30a0(%rdi)
je 0x8ef12
addl $-0x8, %ecx
cmpl $0x4, %ecx
ja 0x8ef12
leaq 0x26bc1(%rip), %rax # 0xb5ac4
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb 0x3080(%rdi), %al
retq
movl 0x3084(%rdi), %eax
movl 0x3088(%rdi), %ecx
shll $0x7, %ecx
movl 0x309c(%rdi), %edx
shll $0x6, %edx
andl $0x40, %edx
orl %ecx, %edx
shrl $0x8, %eax
andl $0x1, %eax
orl %edx, %eax
retq
movb 0x3082(%rdi), %al
retq
movb 0x3084(%rdi), %al
retq
movb 0x3081(%rdi), %al
retq
| /binji[P]binjgb/src/emulator.c |
host_step | EmulatorEvent host_step(Host* host) {
assert(!host->rewind_state.rewinding);
Emulator* e = host_get_emulator(host);
EmulatorEvent event = emulator_step(e);
host_handle_event(host, event);
host->last_ticks = emulator_get_ticks(e);
return event;
} | pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x158(%rdi)
jne 0x9029e
movq %rdi, %rbx
movq 0x70(%rdi), %r14
movq %r14, %rdi
callq 0x82406
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x902bd
movq %r14, %rdi
callq 0x84635
movq %rax, 0x190(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2a222(%rip), %rdi # 0xba4c7
leaq 0x2a19d(%rip), %rsi # 0xba449
leaq 0x2a306(%rip), %rcx # 0xba5b9
movl $0x1c2, %edx # imm = 0x1C2
callq 0x24110
| /binji[P]binjgb/src/host.c |
host_delete | void host_delete(Host* host) {
if (host) {
if (host->init.use_sgb_border) {
host_destroy_texture(host, host->sgb_fb_texture);
}
host_destroy_texture(host, host->fb_texture);
SDL_GL_DeleteContext(host->gl_context);
SDL_DestroyWindow(host->window);
SDL_Quit();
joypad_delete(host->joypad_buffer);
rewind_delete(host->rewind_buffer);
xfree(host->audio.buffer);
xfree(host);
}
} | testq %rdi, %rdi
je 0x90438
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x58(%rdi)
je 0x903e2
movq 0xf0(%rbx), %rsi
callq 0x90439
movq 0xe8(%rbx), %rsi
callq 0x90439
movq 0x88(%rbx), %rdi
callq 0x24080
movq 0x80(%rbx), %rdi
callq 0x243b0
callq 0x24210
movq 0xf8(%rbx), %rdi
callq 0x91d14
movq 0x100(%rbx), %rdi
callq 0x928a6
movq 0xc0(%rbx), %rdi
callq 0x24140
movq %rbx, %rdi
popq %rbx
jmp 0x24140
retq
| /binji[P]binjgb/src/host.c |
host_gl_program | Result host_gl_program(GLuint vert_shader, GLuint frag_shader,
GLuint* out_program) {
GLuint program = glCreateProgram();
glAttachShader(program, vert_shader);
glAttachShader(program, frag_shader);
glLinkProgram(program);
CHECK_LOG(program, Program, GL_LINK_STATUS, "GL_PROGRAM");
*out_program = program;
return OK;
ON_ERROR_RETURN;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %r15d
callq *0x2853ee7(%rip) # 0x28e4ea8
movl %eax, %ebx
movl %eax, %edi
movl %r15d, %esi
callq *0x2853eb2(%rip) # 0x28e4e80
movl %ebx, %edi
movl %ebp, %esi
callq *0x2853ea8(%rip) # 0x28e4e80
movl %ebx, %edi
callq *0x2853f20(%rip) # 0x28e4f00
leaq 0x4(%rsp), %r15
movl %ebx, %edi
movl $0x8b82, %esi # imm = 0x8B82
movq %r15, %rdx
callq *0x2853eeb(%rip) # 0x28e4ee0
cmpl $0x0, (%r15)
je 0x9100b
movl %ebx, (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %r14
movl %ebx, %edi
movl $0x8b84, %esi # imm = 0x8B84
movq %r14, %rdx
callq *0x2853ec2(%rip) # 0x28e4ee0
movslq (%r14), %r14
movq %r14, %rdi
incq %rdi
callq 0x24580
movq %rax, %r15
movl %ebx, %edi
movl %r14d, %esi
xorl %edx, %edx
movq %rax, %rcx
callq *0x2853e99(%rip) # 0x28e4ed8
movq 0x4bf9a(%rip), %rax # 0xdcfe0
movq (%rax), %rdi
leaq 0x2a424(%rip), %rsi # 0xbb474
leaq 0x2a43c(%rip), %rdx # 0xbb493
movq %r15, %rcx
xorl %eax, %eax
callq 0x24160
pushq $0x1
popq %rax
jmp 0x91000
nop
| /binji[P]binjgb/src/host-gl.c |
HostUI::init_gl() | Result HostUI::init_gl() {
static const char* s_vertex_shader =
"in vec2 aPos;\n"
"in vec2 aUV;\n"
"in vec4 aColor;\n"
"out vec2 vUV;\n"
"out vec4 vColor;\n"
"uniform mat3 uProjMatrix;\n"
"void main(void) {\n"
" gl_Position = vec4(uProjMatrix * vec3(aPos, 1.0), 1.0);\n"
" vUV = aUV;\n"
" vColor = aColor;\n"
"}\n";
static const char* s_fragment_shader =
"in vec2 vUV;\n"
"in vec4 vColor;\n"
"out vec4 oColor;\n"
"uniform int uUsePalette;\n"
"uniform vec4 uPalette[4];\n"
"uniform sampler2D uSampler;\n"
"void main(void) {\n"
" vec4 color = vColor * texture(uSampler, vUV);\n"
" if (uUsePalette != 0) {\n"
" color = uPalette[int(clamp(color.x * 256.0, 0.0, 3.0))];\n"
" }\n"
" oColor = color;\n"
"}\n";
glGenBuffers(1, &vbo);
glGenBuffers(1, &ebo);
GLuint vs, fs;
if (!SUCCESS(host_gl_shader(GL_VERTEX_SHADER, s_vertex_shader, &vs)) ||
!SUCCESS(host_gl_shader(GL_FRAGMENT_SHADER, s_fragment_shader, &fs)) ||
!SUCCESS(host_gl_program(vs, fs, &program))) {
return ERROR;
}
GLint aPos = glGetAttribLocation(program, "aPos");
GLint aUV = glGetAttribLocation(program, "aUV");
GLint aColor = glGetAttribLocation(program, "aColor");
uProjMatrix = glGetUniformLocation(program, "uProjMatrix");
uSampler = glGetUniformLocation(program, "uSampler");
uUsePalette = glGetUniformLocation(program, "uUsePalette");
uPalette = glGetUniformLocation(program, "uPalette[0]");
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glEnableVertexAttribArray(aPos);
glEnableVertexAttribArray(aUV);
glEnableVertexAttribArray(aColor);
glVertexAttribPointer(aPos, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert),
(void*)offsetof(ImDrawVert, pos));
glVertexAttribPointer(aUV, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert),
(void*)offsetof(ImDrawVert, uv));
glVertexAttribPointer(aColor, 4, GL_UNSIGNED_BYTE, GL_TRUE,
sizeof(ImDrawVert), (void*)offsetof(ImDrawVert, col));
return OK;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x2853d68(%rip), %r14 # 0x28e4ec0
leaq 0x4c(%rdi), %rsi
pushq $0x1
popq %r12
movl %r12d, %edi
callq *(%r14)
leaq 0x50(%rbx), %rsi
movl %r12d, %edi
callq *(%r14)
leaq 0x2a38d(%rip), %rsi # 0xbb504
leaq 0x14(%rsp), %rdx
movl $0x8b31, %edi # imm = 0x8B31
callq 0x90e39
testl %eax, %eax
jne 0x912e4
leaq 0x2a442(%rip), %rsi # 0xbb5d7
leaq 0x10(%rsp), %rdx
movl $0x8b30, %edi # imm = 0x8B30
callq 0x90e39
testl %eax, %eax
jne 0x912e4
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
leaq 0x54(%rbx), %rdx
callq 0x90fac
testl %eax, %eax
jne 0x912e4
leaq 0x2853d04(%rip), %r12 # 0x28e4ed0
movl 0x54(%rbx), %edi
leaq 0x2a530(%rip), %rsi # 0xbb706
callq *(%r12)
movl %eax, %r15d
movl 0x54(%rbx), %edi
leaq 0x2a524(%rip), %rsi # 0xbb70b
callq *(%r12)
movl %eax, %r14d
movl 0x54(%rbx), %edi
leaq 0x2a517(%rip), %rsi # 0xbb70f
callq *(%r12)
movl %eax, %ebp
movl %eax, 0xc(%rsp)
leaq 0x2853cef(%rip), %r12 # 0x28e4ef8
movl 0x54(%rbx), %edi
leaq 0x2a503(%rip), %rsi # 0xbb716
callq *(%r12)
movl %eax, 0x58(%rbx)
movl 0x54(%rbx), %edi
leaq 0x2a4fe(%rip), %rsi # 0xbb722
callq *(%r12)
movl %eax, 0x5c(%rbx)
movl 0x54(%rbx), %edi
leaq 0x2a4f6(%rip), %rsi # 0xbb72b
callq *(%r12)
movl %eax, 0x60(%rbx)
movl 0x54(%rbx), %edi
leaq 0x2a4f1(%rip), %rsi # 0xbb737
callq *(%r12)
movl %eax, 0x64(%rbx)
leaq 0x2853c74(%rip), %rax # 0x28e4ec8
leaq 0x48(%rbx), %rsi
pushq $0x1
popq %rdi
callq *(%rax)
leaq 0x2853c2c(%rip), %rax # 0x28e4e90
movl 0x48(%rbx), %edi
callq *(%rax)
leaq 0x2853c18(%rip), %rax # 0x28e4e88
movl 0x4c(%rbx), %esi
movl $0x8892, %edi # imm = 0x8892
callq *(%rax)
leaq 0x2853c37(%rip), %rbx # 0x28e4eb8
movl %r15d, %edi
callq *(%rbx)
movl %r14d, %edi
callq *(%rbx)
movl %ebp, %edi
callq *(%rbx)
leaq 0x2853c9a(%rip), %rbp # 0x28e4f30
xorl %r12d, %r12d
pushq $0x2
popq %rbx
pushq $0x14
popq %r13
movl %r15d, %edi
movl %ebx, %esi
movl $0x1406, %edx # imm = 0x1406
xorl %ecx, %ecx
movl %r13d, %r8d
xorl %r9d, %r9d
callq *(%rbp)
pushq $0x8
popq %r9
movl %r14d, %edi
movl %ebx, %esi
movl $0x1406, %edx # imm = 0x1406
xorl %ecx, %ecx
movl %r13d, %r8d
callq *(%rbp)
pushq $0x4
popq %rsi
pushq $0x10
popq %r9
movl 0xc(%rsp), %edi
movl $0x1401, %edx # imm = 0x1401
pushq $0x1
popq %rcx
movl %r13d, %r8d
callq *(%rbp)
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /binji[P]binjgb/src/host-ui-imgui.cc |
HostUI::init_font() | void HostUI::init_font() {
ImGuiIO& io = ImGui::GetIO();
// Load as RGBA 32-bits for OpenGL3 demo because it is more likely to be
// compatible with user's existing shader.
unsigned char* pixels;
int width, height;
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
// Upload texture to graphics system
glGenTextures(1, &font_texture);
glBindTexture(GL_TEXTURE_2D, font_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
GL_UNSIGNED_BYTE, pixels);
// Store our identifier
io.Fonts->TexID = (void*)(intptr_t)font_texture;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x293d5
movq %rax, %r14
movq 0xa0(%rax), %rdi
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r12
movq %rsp, %r13
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0x51580
leaq 0x44(%rbx), %rsi
pushq $0x1
popq %rdi
callq 0x24270
movl 0x44(%rbx), %esi
movl $0xde1, %edi # imm = 0xDE1
callq 0x246e0
movl $0xde1, %edi # imm = 0xDE1
movl $0x2801, %esi # imm = 0x2801
movl $0x2601, %edx # imm = 0x2601
callq 0x244b0
movl $0xde1, %edi # imm = 0xDE1
movl $0x2800, %esi # imm = 0x2800
movl $0x2601, %edx # imm = 0x2601
callq 0x244b0
movl $0xcf2, %edi # imm = 0xCF2
xorl %esi, %esi
callq 0x245f0
movl (%r12), %ecx
movl (%r13), %r8d
subq $0x8, %rsp
movl $0xde1, %edi # imm = 0xDE1
xorl %esi, %esi
movl $0x1908, %edx # imm = 0x1908
xorl %r9d, %r9d
pushq (%r15)
pushq $0x1401 # imm = 0x1401
pushq $0x1908 # imm = 0x1908
callq 0x24660
addq $0x20, %rsp
movl 0x44(%rbx), %eax
movq 0xa0(%r14), %rcx
movq %rax, 0x8(%rcx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /binji[P]binjgb/src/host-ui-imgui.cc |
HostUI::event(SDL_Event*) | void HostUI::event(union SDL_Event* event) {
ImGuiIO& io = ImGui::GetIO();
switch (event->type) {
case SDL_WINDOWEVENT:
switch (event->window.event) {
case SDL_WINDOWEVENT_SHOWN:
case SDL_WINDOWEVENT_SIZE_CHANGED: {
ImGuiIO& io = ImGui::GetIO();
int iw, ih;
SDL_GetWindowSize(window, &iw, &ih);
f32 w = iw, h = ih;
int display_w, display_h;
SDL_GL_GetDrawableSize(window, &display_w, &display_h);
io.DisplaySize = ImVec2(w, h);
io.DisplayFramebufferScale =
ImVec2(w > 0 ? (display_w / w) : 0, h > 0 ? (display_h / h) : 0);
memset(proj_matrix, 0, sizeof(proj_matrix));
proj_matrix[0] = 2.0f / w;
proj_matrix[4] = -2.0f / h;
proj_matrix[6] = -1.0f;
proj_matrix[7] = 1.0f;
proj_matrix[8] = 1.0f;
break;
}
}
break;
case SDL_MOUSEWHEEL:
if (event->wheel.y > 0) mouse_wheel = 1;
if (event->wheel.y < 0) mouse_wheel = -1;
break;
case SDL_MOUSEBUTTONDOWN:
if (event->button.button == SDL_BUTTON_LEFT) mouse_pressed[0] = true;
if (event->button.button == SDL_BUTTON_RIGHT) mouse_pressed[1] = true;
if (event->button.button == SDL_BUTTON_MIDDLE) mouse_pressed[2] = true;
break;
case SDL_TEXTINPUT:
io.AddInputCharactersUTF8(event->text.text);
break;
case SDL_KEYDOWN:
case SDL_KEYUP: {
int key = event->key.keysym.scancode;
io.KeysDown[key] = (event->type == SDL_KEYDOWN);
io.KeyShift = ((SDL_GetModState() & KMOD_SHIFT) != 0);
io.KeyCtrl = ((SDL_GetModState() & KMOD_CTRL) != 0);
io.KeyAlt = ((SDL_GetModState() & KMOD_ALT) != 0);
io.KeySuper = ((SDL_GetModState() & KMOD_GUI) != 0);
break;
}
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x293d5
movq %rax, %r15
movl (%r14), %eax
leal -0x300(%rax), %ecx
cmpl $0x2, %ecx
jb 0x91587
cmpl $0x403, %eax # imm = 0x403
je 0x915db
cmpl $0x303, %eax # imm = 0x303
je 0x91634
cmpl $0x401, %eax # imm = 0x401
je 0x915fb
cmpl $0x200, %eax # imm = 0x200
jne 0x91628
movzbl 0xc(%r14), %eax
cmpl $0x6, %eax
je 0x914c0
cmpl $0x1, %eax
jne 0x91628
callq 0x293d5
movq %rax, %r14
movq (%rbx), %rdi
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x244d0
movss (%r12), %xmm0
movss (%r15), %xmm1
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps %xmm1, 0x10(%rsp)
movq (%rbx), %rdi
leaq 0x4(%rsp), %r15
movq %rsp, %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x24590
movaps 0x10(%rsp), %xmm3
cvtdq2ps %xmm3, %xmm0
movd (%r12), %xmm1
movd (%r15), %xmm2
punpckldq %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
movlps %xmm0, 0x8(%r14)
pxor %xmm1, %xmm1
pcmpgtd %xmm1, %xmm3
cvtdq2ps %xmm2, %xmm2
divps %xmm0, %xmm2
andps %xmm3, %xmm2
movlps %xmm2, 0xb8(%r14)
andq $0x0, 0x30(%rbx)
movdqu %xmm1, 0x20(%rbx)
movss 0xbeac(%rip), %xmm1 # 0x9d3fc
divss %xmm0, %xmm1
movss %xmm1, 0x20(%rbx)
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movss 0xbebf(%rip), %xmm1 # 0x9d424
divss %xmm0, %xmm1
movss %xmm1, 0x30(%rbx)
movsd 0x29f6a(%rip), %xmm0 # 0xbb4e0
movsd %xmm0, 0x38(%rbx)
movl $0x3f800000, 0x40(%rbx) # imm = 0x3F800000
jmp 0x91628
movslq 0x10(%r14), %rcx
cmpl $0x300, %eax # imm = 0x300
sete 0x138(%r15,%rcx)
callq 0x245a0
testb $0x3, %al
setne 0x135(%r15)
callq 0x245a0
testb $-0x40, %al
setne 0x134(%r15)
callq 0x245a0
testw $0x300, %ax # imm = 0x300
setne 0x136(%r15)
callq 0x245a0
testw $0xc00, %ax # imm = 0xC00
setne 0x137(%r15)
jmp 0x91628
movl 0x14(%r14), %eax
testl %eax, %eax
jle 0x915ee
movl $0x3f800000, 0x10(%rbx) # imm = 0x3F800000
movl 0x14(%r14), %eax
testl %eax, %eax
jns 0x91628
movl $0xbf800000, 0x10(%rbx) # imm = 0xBF800000
jmp 0x91628
movb 0x10(%r14), %al
cmpb $0x1, %al
jne 0x9160e
movl $0x3f800000, 0x14(%rbx) # imm = 0x3F800000
movb 0x10(%r14), %al
cmpb $0x3, %al
jne 0x9161d
movl $0x3f800000, 0x18(%rbx) # imm = 0x3F800000
movb 0x10(%r14), %al
cmpb $0x2, %al
jne 0x91628
movl $0x3f800000, 0x1c(%rbx) # imm = 0x3F800000
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0xc, %r14
movq %r15, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x24d84
| /binji[P]binjgb/src/host-ui-imgui.cc |
HostUI::render_draw_lists(ImDrawData*) | void HostUI::render_draw_lists(ImDrawData* draw_data) {
ImGuiIO& io = ImGui::GetIO();
int fb_width = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x);
int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y);
if (fb_width == 0 || fb_height == 0) {
return;
}
draw_data->ScaleClipRects(io.DisplayFramebufferScale);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
glUseProgram(program);
glUniform1i(uSampler, 0);
glUniformMatrix3fv(uProjMatrix, 1, GL_FALSE, proj_matrix);
glBindVertexArray(vao);
for (int n = 0; n < draw_data->CmdListsCount; n++) {
const ImDrawList* cmd_list = draw_data->CmdLists[n];
const ImDrawIdx* idx_buffer_offset = 0;
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER,
(GLsizeiptr)cmd_list->VtxBuffer.Size * sizeof(ImDrawVert),
(GLvoid*)cmd_list->VtxBuffer.Data, GL_STREAM_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
(GLsizeiptr)cmd_list->IdxBuffer.Size * sizeof(ImDrawIdx),
(GLvoid*)cmd_list->IdxBuffer.Data, GL_STREAM_DRAW);
for (int i = 0; i < cmd_list->CmdBuffer.Size; i++) {
const ImDrawCmd* cmd = &cmd_list->CmdBuffer[i];
if (cmd->UserCallback) {
cmd->UserCallback(cmd_list, cmd);
} else {
glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)cmd->TextureId);
glScissor((int)cmd->ClipRect.x, (int)(fb_height - cmd->ClipRect.w),
(int)(cmd->ClipRect.z - cmd->ClipRect.x),
(int)(cmd->ClipRect.w - cmd->ClipRect.y));
glDrawElements(
GL_TRIANGLES, (GLsizei)cmd->ElemCount,
sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT,
idx_buffer_offset);
}
idx_buffer_offset += cmd->ElemCount;
}
}
glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r12
callq 0x293d5
movsd 0x8(%rax), %xmm0
movsd 0xb8(%rax), %xmm1
mulps %xmm0, %xmm1
cvttps2dq %xmm1, %xmm2
pshufd $0x50, %xmm2, %xmm0 # xmm0 = xmm2[0,0,1,1]
xorps %xmm1, %xmm1
pcmpeqd %xmm0, %xmm1
movmskpd %xmm1, %ecx
testl %ecx, %ecx
je 0x91884
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0xb8, %rax
movq %rbx, %rdi
movq %rax, %rsi
movdqa %xmm2, (%rsp)
callq 0x510b6
movl $0xbe2, %edi # imm = 0xBE2
callq 0x24390
movl $0x302, %edi # imm = 0x302
movl $0x303, %esi # imm = 0x303
callq 0x246c0
movl $0xb44, %edi # imm = 0xB44
callq 0x245c0
movl $0xb71, %edi # imm = 0xB71
callq 0x245c0
movl $0xc11, %edi # imm = 0xC11
callq 0x24390
leaq 0x2853650(%rip), %rax # 0x28e4f28
movl 0x54(%r12), %edi
callq *(%rax)
leaq 0x285362a(%rip), %rax # 0x28e4f10
movl 0x5c(%r12), %edi
xorl %r14d, %r14d
xorl %esi, %esi
callq *(%rax)
leaq 0x2853627(%rip), %rax # 0x28e4f20
movl 0x58(%r12), %edi
leaq 0x20(%r12), %rcx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq *(%rax)
leaq 0x285357f(%rip), %rax # 0x28e4e90
movl 0x48(%r12), %edi
callq *(%rax)
pshufd $0x55, (%rsp), %xmm0 # xmm0 = mem[1,1,1,1]
cvtdq2ps %xmm0, %xmm0
movaps %xmm0, (%rsp)
pushq $0x4
popq %rbp
movq %rbx, 0x20(%rsp)
movq %r12, 0x18(%rsp)
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jge 0x91a44
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %r15
movl 0x4c(%r12), %esi
movl $0x8892, %edi # imm = 0x8892
leaq 0x2853530(%rip), %rbx # 0x28e4e88
callq *(%rbx)
movslq 0x20(%r15), %rax
imulq $0x14, %rax, %rsi
movq 0x28(%r15), %rdx
movl $0x8892, %edi # imm = 0x8892
movl $0x88e0, %ecx # imm = 0x88E0
leaq 0x2853521(%rip), %r13 # 0x28e4e98
callq *(%r13)
movl 0x50(%r12), %esi
movl $0x8893, %edi # imm = 0x8893
callq *(%rbx)
movslq 0x10(%r15), %rsi
addq %rsi, %rsi
movq 0x18(%r15), %rdx
movl $0x8893, %edi # imm = 0x8893
movl $0x88e0, %ecx # imm = 0x88E0
callq *(%r13)
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpl (%r15), %r13d
jge 0x91a32
movq %r15, %rdi
movl %r13d, %esi
callq 0x91c30
movq %rax, %rbx
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x919d0
movq %r15, %rdi
movq %rbx, %rsi
callq *%rax
jmp 0x91a23
movl 0x10(%rbx), %esi
movl $0xde1, %edi # imm = 0xDE1
callq 0x246e0
movss (%rbx), %xmm0
cvttss2si %xmm0, %edi
movss 0xc(%rbx), %xmm1
movaps (%rsp), %xmm2
subss %xmm1, %xmm2
cvttss2si %xmm2, %esi
movss 0x8(%rbx), %xmm2
subss %xmm0, %xmm2
cvttss2si %xmm2, %edx
subss 0x4(%rbx), %xmm1
cvttss2si %xmm1, %ecx
callq 0x243c0
movl 0x20(%rbx), %esi
movl %ebp, %edi
movl $0x1403, %edx # imm = 0x1403
movq %r12, %rcx
callq 0x24180
movl 0x20(%rbx), %eax
leaq (%r12,%rax,2), %r12
incl %r13d
jmp 0x919a6
incq %r14
movq 0x20(%rsp), %rbx
movq 0x18(%rsp), %r12
jmp 0x91932
movl $0xc11, %edi # imm = 0xC11
callq 0x245c0
movl $0xbe2, %edi # imm = 0xBE2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x245c0
| /binji[P]binjgb/src/host-ui-imgui.cc |
HostUI::set_palette(unsigned int*) | void HostUI::set_palette(RGBA palette[4]) {
GLfloat p[16];
for (int i = 0; i < 4; ++i) {
p[i * 4 + 0] = ((palette[i] >> 0) & 255) / 255.0f;
p[i * 4 + 1] = ((palette[i] >> 8) & 255) / 255.0f;
p[i * 4 + 2] = ((palette[i] >> 16) & 255) / 255.0f;
p[i * 4 + 3] = 1.0f;
}
glUseProgram(program);
glUniform4fv(uPalette, 4, p);
} | pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq 0x29a2c(%rip), %xmm0 # 0xbb4f0
movaps 0xb655(%rip), %xmm1 # 0x9d120
movss 0xb909(%rip), %xmm2 # 0x9d3dc
cmpq $0x10, %rax
je 0x91b1d
movl (%rsi,%rax), %ecx
movl %ecx, %edx
shrl $0x8, %edx
movd %ecx, %xmm3
movd %edx, %xmm4
punpckldq %xmm4, %xmm3 # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1]
pand %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
divps %xmm1, %xmm3
movlps %xmm3, (%rsp,%rax,4)
shrl $0x10, %ecx
movzbl %cl, %ecx
cvtsi2ss %ecx, %xmm3
divss %xmm2, %xmm3
movss %xmm3, 0x8(%rsp,%rax,4)
movl $0x3f800000, 0xc(%rsp,%rax,4) # imm = 0x3F800000
addq $0x4, %rax
jmp 0x91ad3
leaq 0x2853404(%rip), %rax # 0x28e4f28
movl 0x54(%rbx), %edi
callq *(%rax)
leaq 0x28533e8(%rip), %rax # 0x28e4f18
movl 0x64(%rbx), %edi
pushq $0x4
popq %rsi
movq %rsp, %rdx
callq *(%rax)
addq $0x40, %rsp
popq %rbx
retq
nop
| /binji[P]binjgb/src/host-ui-imgui.cc |
joypad_append | void joypad_append(JoypadBuffer* buffer, JoypadButtons* buttons, Ticks ticks) {
JoypadState* state = alloc_joypad_state(buffer);
state->ticks = ticks;
state->buttons = joypad_pack_buttons(buttons);
buffer->last_buttons = *buttons;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %r13
movq 0x8(%r13), %r12
cmpq 0x10(%r13), %r12
jb 0x91cd1
movl $0x1000, %edi # imm = 0x1000
callq 0x9224c
movq %rbx, 0x18(%rax)
movq %r13, 0x20(%rax)
movq %rax, 0x18(%r13)
movq %rax, 0x20(%rbx)
movq 0x8(%rax), %r12
movq %rax, %r13
movq (%r13), %rbp
leaq 0x1(%r12), %rax
movq %rax, 0x8(%r13)
shlq $0x4, %r12
movq %r15, (%rbp,%r12)
movq %r14, %rdi
callq 0x91d51
movb %al, 0x8(%rbp,%r12)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, 0x28(%rbx)
movups %xmm1, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /binji[P]binjgb/src/joypad.c |
joypad_find_state | JoypadStateIter joypad_find_state(JoypadBuffer* buffer, Ticks ticks) {
/* TODO(binji): Use a skip list if this is too slow? */
JoypadStateIter result;
JoypadChunk* first_chunk = buffer->sentinel.next;
JoypadChunk* last_chunk = buffer->sentinel.prev;
assert(first_chunk->size != 0 && last_chunk->size != 0);
Ticks first_ticks = first_chunk->data[0].ticks;
Ticks last_ticks = last_chunk->data[last_chunk->size - 1].ticks;
if (ticks <= first_ticks) {
/* At or past the beginning. */
result.chunk = first_chunk;
result.state = &first_chunk->data[0];
return result;
} else if (ticks >= last_ticks) {
/* At or past the end. */
result.chunk = last_chunk;
result.state = &last_chunk->data[last_chunk->size - 1];
return result;
} else if (ticks - first_ticks < last_ticks - ticks) {
/* Closer to the beginning. */
JoypadChunk* chunk = first_chunk;
while (ticks >= chunk->data[chunk->size - 1].ticks) {
chunk = chunk->next;
}
result.chunk = chunk;
} else {
/* Closer to the end. */
JoypadChunk* chunk = last_chunk;
while (ticks < chunk->data[0].ticks) {
chunk = chunk->prev;
}
result.chunk = chunk;
}
JoypadState* begin = result.chunk->data;
JoypadState* end = begin + result.chunk->size;
LOWER_BOUND(JoypadState, lower_bound, begin, end, ticks, GET_TICKS, CMP_LT);
assert(lower_bound != NULL); /* The chunk should not be empty. */
result.state = lower_bound;
assert(result.state->ticks <= ticks);
return result;
} | pushq %rax
movq 0x18(%rdi), %r8
movq 0x8(%r8), %rcx
testq %rcx, %rcx
je 0x91eb9
movq 0x20(%rdi), %rax
movq 0x8(%rax), %r9
testq %r9, %r9
je 0x91eb9
movq (%r8), %rdx
movq %rsi, %r10
subq (%rdx), %r10
jbe 0x91e56
movq (%rax), %rdi
shlq $0x4, %r9
movq -0x10(%rdi,%r9), %r11
subq %rsi, %r11
jbe 0x91e5b
cmpq %r11, %r10
jae 0x91e48
movq %rcx, %rax
shlq $0x4, %rax
cmpq %rsi, -0x10(%rdx,%rax)
ja 0x91e65
movq 0x18(%r8), %r8
movq (%r8), %rdx
movq 0x8(%r8), %rcx
jmp 0x91e2d
cmpq %rsi, (%rdi)
jbe 0x91e6a
movq 0x20(%rax), %rax
movq (%rax), %rdi
jmp 0x91e48
movq %r8, %rax
jmp 0x91eb7
leaq (%rdi,%r9), %rdx
addq $-0x10, %rdx
jmp 0x91eb7
movq %r8, %rax
jmp 0x91e6e
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x91ed6
movq (%rax), %rdi
shlq $0x4, %rcx
addq %rdi, %rcx
movq %rcx, %rdx
subq %rdi, %rdx
sarq $0x4, %rdx
cmpq $0x2, %rdx
jl 0x91eaa
andq $-0x2, %rdx
leaq (%rdi,%rdx,8), %rdx
movq %rdx, %r8
cmpq %rsi, (%rdx)
ja 0x91ea3
movq %rdx, %rdi
movq %rcx, %r8
movq %r8, %rcx
jne 0x91e7d
jmp 0x91eb2
movq %rdi, %rdx
testq %rdi, %rdi
je 0x91ed6
cmpq %rsi, (%rdx)
ja 0x91ef5
popq %rcx
retq
leaq 0x29970(%rip), %rdi # 0xbb830
leaq 0x29999(%rip), %rsi # 0xbb860
leaq 0x299e0(%rip), %rcx # 0xbb8ae
pushq $0x65
popq %rdx
callq 0x24110
leaq 0x29a0a(%rip), %rdi # 0xbb8e7
leaq 0x2997c(%rip), %rsi # 0xbb860
leaq 0x299c3(%rip), %rcx # 0xbb8ae
movl $0x85, %edx
callq 0x24110
leaq 0x299ff(%rip), %rdi # 0xbb8fb
leaq 0x2995d(%rip), %rsi # 0xbb860
leaq 0x299a4(%rip), %rcx # 0xbb8ae
movl $0x88, %edx
callq 0x24110
| /binji[P]binjgb/src/joypad.c |
joypad_unpack_buttons | JoypadButtons joypad_unpack_buttons(u8 packed) {
JoypadButtons buttons;
buttons.A = packed & 1;
buttons.B = (packed >> 1) & 1;
buttons.select = (packed >> 2) & 1;
buttons.start = (packed >> 3) & 1;
buttons.right = (packed >> 4) & 1;
buttons.left = (packed >> 5) & 1;
buttons.up = (packed >> 6) & 1;
buttons.down = (packed >> 7) & 1;
return buttons;
} | movq %rdi, %rax
movl %esi, %ecx
andl $0x1, %ecx
movl %ecx, 0x1c(%rdi)
movl %esi, %ecx
shrl %ecx
andl $0x1, %ecx
movl %ecx, 0x18(%rdi)
movl %esi, %ecx
shrl $0x2, %ecx
andl $0x1, %ecx
movl %ecx, 0x14(%rdi)
movl %esi, %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
movl %ecx, 0x10(%rdi)
movl %esi, %ecx
shrl $0x4, %ecx
andl $0x1, %ecx
movl %ecx, 0xc(%rdi)
movl %esi, %ecx
shrl $0x5, %ecx
andl $0x1, %ecx
movl %ecx, 0x8(%rdi)
movl %esi, %ecx
shrl $0x6, %ecx
andl $0x1, %ecx
movl %ecx, 0x4(%rdi)
shrl $0x7, %esi
movl %esi, (%rdi)
retq
| /binji[P]binjgb/src/joypad.c |
joypad_get_next_state | JoypadStateIter joypad_get_next_state(JoypadStateIter iter) {
size_t index = iter.state - iter.chunk->data;
if (index + 1 < iter.chunk->size) {
++iter.state;
return iter;
}
iter.chunk = iter.chunk->next;
iter.state = iter.chunk->size != 0 ? iter.chunk->data : NULL;
return iter;
} | movq %rdi, %rax
movq %rsi, %rcx
subq (%rdi), %rcx
sarq $0x4, %rcx
incq %rcx
cmpq 0x8(%rdi), %rcx
jae 0x92006
movq %rsi, %rdx
addq $0x10, %rdx
retq
movq 0x18(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x92015
movq (%rax), %rdx
retq
xorl %edx, %edx
retq
| /binji[P]binjgb/src/joypad.c |
joypad_get_stats | JoypadStats joypad_get_stats(JoypadBuffer* buffer) {
JoypadStats stats;
ZERO_MEMORY(stats);
JoypadChunk* sentinel = &buffer->sentinel;
JoypadChunk* cur = sentinel->next;
while (cur != sentinel) {
size_t overhead = sizeof(*cur);
stats.used_bytes += cur->size * sizeof(JoypadState) + overhead;
stats.capacity_bytes += cur->capacity * sizeof(JoypadState) + overhead;
cur = cur->next;
}
return stats;
} | pxor %xmm0, %xmm0
movdqa 0x297fc(%rip), %xmm1 # 0xbb820
movq %rdi, %rax
movq 0x18(%rax), %rax
cmpq %rdi, %rax
je 0x92044
movdqu 0x8(%rax), %xmm2
psllq $0x4, %xmm2
paddq %xmm2, %xmm0
paddq %xmm1, %xmm0
jmp 0x92027
movq %xmm0, %rax
pshufd $0xee, %xmm0, %xmm0 # xmm0 = xmm0[2,3,2,3]
movq %xmm0, %rdx
retq
| /binji[P]binjgb/src/joypad.c |
joypad_read | Result joypad_read(const FileData* file_data, JoypadBuffer** out_buffer) {
CHECK_MSG(file_data->size % sizeof(JoypadState) == 0,
"Expected joypad file size to be multiple of %zu\n",
sizeof(JoypadState));
size_t size = file_data->size / sizeof(JoypadState);
size_t i;
Ticks last_ticks = 0;
for (i = 0; i < size; ++i) {
JoypadState* state = (JoypadState*)file_data->data + i;
Ticks ticks = state->ticks;
CHECK_MSG(ticks >= last_ticks,
"Expected ticks to be sorted, got %" PRIu64 " then %" PRIu64 "\n",
last_ticks, ticks);
size_t j;
for (j = 0; j < ARRAY_SIZE(state->padding); ++j) {
CHECK_MSG(state->padding[j] == 0, "Expected padding to be zero, got %u\n",
state->padding[i]);
}
last_ticks = ticks;
}
JoypadBuffer* buffer = xcalloc(1, sizeof(JoypadBuffer));
JoypadChunk* new_chunk = alloc_joypad_chunk(size);
memcpy(new_chunk->data, file_data->data, file_data->size);
new_chunk->size = size;
new_chunk->prev = new_chunk->next = &buffer->sentinel;
buffer->sentinel.prev = buffer->sentinel.next = new_chunk;
*out_buffer = buffer;
return OK;
ON_ERROR_RETURN;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
testb $0xf, %r14b
jne 0x921cf
movq %rsi, %r8
movq %rdi, %r15
shrq $0x4, %r14
pushq $0x9
popq %rax
xorl %r13d, %r13d
pushq $-0x7
popq %rcx
xorl %ebx, %ebx
cmpq %r14, %rbx
je 0x9217a
movq (%r15), %rdx
movq %rbx, %rbp
shlq $0x4, %rbp
movq (%rdx,%rbp), %r12
cmpq %r13, %r12
jb 0x9220c
addq %rdx, %rbp
addq %rax, %rdx
movq %rcx, %rsi
testq %rsi, %rsi
je 0x9212f
cmpb $0x0, 0x7(%rdx,%rsi)
leaq 0x1(%rsi), %rsi
je 0x9211d
jmp 0x9213b
incq %rbx
addq $0x10, %rax
movq %r12, %r13
jmp 0x920f8
movq 0x4ae9e(%rip), %r14 # 0xdcfe0
movq (%r14), %rdi
leaq 0x22ad8(%rip), %rsi # 0xb4c24
leaq 0x2970d(%rip), %rdx # 0xbb860
movl $0xf4, %ecx
xorl %eax, %eax
callq 0x24160
movq (%r14), %rdi
movzbl 0x9(%rbp,%rbx), %edx
leaq 0x2980a(%rip), %rsi # 0xbb978
xorl %eax, %eax
callq 0x24160
pushq $0x1
popq %rax
jmp 0x921c0
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
movq %r8, %rbx
callq 0x24530
movq %rax, %r12
movq %r14, %rdi
callq 0x9224c
movq %rax, %r13
movq (%rax), %rdi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
callq 0x24070
movq %r14, 0x8(%r13)
movq %r12, 0x18(%r13)
movq %r12, 0x20(%r13)
movq %r13, 0x18(%r12)
movq %r13, 0x20(%r12)
movq %r12, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4ae0a(%rip), %rbx # 0xdcfe0
movq (%rbx), %rdi
leaq 0x22a44(%rip), %rsi # 0xb4c24
leaq 0x29679(%rip), %rdx # 0xbb860
movl $0xe7, %ecx
xorl %eax, %eax
callq 0x24160
movq (%rbx), %rdi
leaq 0x2971b(%rip), %rsi # 0xbb918
pushq $0x10
popq %rdx
xorl %eax, %eax
callq 0x24160
jmp 0x92175
movq 0x4adcd(%rip), %rbx # 0xdcfe0
movq (%rbx), %rdi
leaq 0x22a07(%rip), %rsi # 0xb4c24
leaq 0x2963c(%rip), %rdx # 0xbb860
movl $0xf0, %ecx
xorl %eax, %eax
callq 0x24160
movq (%rbx), %rdi
leaq 0x2970f(%rip), %rsi # 0xbb949
movq %r13, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x24160
jmp 0x92175
| /binji[P]binjgb/src/joypad.c |
rewind_new | RewindBuffer* rewind_new(const RewindInit* init, Emulator* e) {
RewindBuffer* buffer = xmalloc(sizeof(RewindBuffer));
ZERO_MEMORY(*buffer);
buffer->init = *init;
size_t capacity = init->buffer_capacity;
u8* data = xmalloc(capacity);
emulator_init_state_file_data(&buffer->last_state);
emulator_init_state_file_data(&buffer->last_base_state);
emulator_init_state_file_data(&buffer->rewind_diff_state);
buffer->last_base_state_ticks = INVALID_TICKS;
buffer->data_range[0].begin = buffer->data_range[0].end = data;
buffer->data_range[1] = buffer->data_range[0];
RewindInfo* info = (RewindInfo*)(data + capacity);
buffer->info_range[0].begin = buffer->info_range[0].end = info;
buffer->info_range[1] = buffer->info_range[0];
buffer->frames_until_next_base = 0;
rewind_append(buffer, e);
return buffer;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl $0xa8, %edi
callq 0x24580
movq %rax, %r14
leaq 0x10(%rax), %rdi
movl $0x98, %edx
xorl %esi, %esi
callq 0x241f0
movups (%r15), %xmm0
movups %xmm0, (%r14)
movq (%r15), %r15
movq %r15, %rdi
callq 0x24580
movq %rax, %r12
leaq 0x50(%r14), %rdi
callq 0x846fa
leaq 0x60(%r14), %rdi
callq 0x846fa
leaq 0x80(%r14), %rdi
callq 0x846fa
orq $-0x1, 0x70(%r14)
movq %r12, 0x18(%r14)
movq %r12, 0x10(%r14)
movq 0x10(%r14), %rax
movq %rax, 0x20(%r14)
movq 0x18(%r14), %rax
movq %rax, 0x28(%r14)
addq %r15, %r12
movq %r12, 0x38(%r14)
movq %r12, 0x30(%r14)
movq 0x30(%r14), %rax
movq %rax, 0x40(%r14)
movq 0x38(%r14), %rax
movq %rax, 0x48(%r14)
andl $0x0, 0x78(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x924a6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /binji[P]binjgb/src/rewind.c |
rewind_get_newest_ticks | Ticks rewind_get_newest_ticks(RewindBuffer* buffer) {
RewindInfoRange* info_range = buffer->info_range;
int i;
for (i = 0; i < 2; ++i) {
if (!is_rewind_range_empty(&info_range[i])) {
return info_range[i].begin[0].ticks;
}
}
return INVALID_TICKS;
} | movq 0x30(%rdi), %rax
cmpq %rax, 0x38(%rdi)
jne 0x928ee
movq 0x40(%rdi), %rax
cmpq %rax, 0x48(%rdi)
je 0x928f2
movq (%rax), %rax
retq
pushq $-0x1
popq %rax
retq
| /binji[P]binjgb/src/rewind.c |
decode_rle | static void decode_rle(const u8* src, size_t src_size, u8* dst, u8* dst_end) {
#define WRITE(x) *dst++ = (x)
DECODE_RLE(WRITE, src, src_size);
#undef WRITE
assert(dst == dst_end);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0x92cb6
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
addq %rdi, %r15
movb (%rdi), %bpl
incq %rdi
movb %bpl, (%rdx)
incq %r14
leaq 0x8(%rsp), %r12
cmpq %r15, %rdi
jae 0x92ca4
leaq 0x1(%rdi), %rax
movq %rax, 0x8(%rsp)
movb (%rdi), %al
cmpb %bpl, %al
jne 0x92c95
movq %r12, %rdi
callq 0x92e62
incl %eax
subl $0x1, %eax
jb 0x92c9d
movb %bpl, (%r14)
incq %r14
jmp 0x92c88
movb %al, (%r14)
incq %r14
movl %eax, %ebp
movq 0x8(%rsp), %rdi
jmp 0x92c69
cmpq %rbx, %r14
jne 0x92cd5
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28f16(%rip), %rdi # 0xbbbd3
leaq 0x28dab(%rip), %rsi # 0xbba6f
leaq 0x28fb3(%rip), %rcx # 0xbbc7e
movl $0xa9, %edx
callq 0x24110
leaq 0x28fd2(%rip), %rdi # 0xbbcae
leaq 0x28d8c(%rip), %rsi # 0xbba6f
leaq 0x28f94(%rip), %rcx # 0xbbc7e
movl $0xab, %edx
callq 0x24110
| /binji[P]binjgb/src/rewind.c |
rewind_get_stats | RewindStats rewind_get_stats(RewindBuffer* buffer) {
RewindStats stats;
ZERO_MEMORY(stats);
stats.base_bytes = buffer->total_kind_bytes[RewindInfoKind_Base];
stats.diff_bytes = buffer->total_kind_bytes[RewindInfoKind_Diff];
stats.uncompressed_bytes = buffer->total_uncompressed_bytes;
stats.used_bytes = 0;
stats.capacity_bytes = buffer->init.buffer_capacity;
u8* begin = buffer->data_range[0].begin;
int i;
for (i = 0; i < 2; ++i) {
RewindDataRange* data_range = &buffer->data_range[i];
RewindInfoRange* info_range = &buffer->info_range[i];
stats.used_bytes += data_range->end - data_range->begin;
stats.used_bytes +=
(info_range->end - info_range->begin) * sizeof(RewindInfo);
stats.data_ranges[i*2+0] = data_range->begin - begin;
stats.data_ranges[i*2+1] = data_range->end - begin;
stats.info_ranges[i*2+0] = (u8*)info_range->begin - begin;
stats.info_ranges[i*2+1] = (u8*)info_range->end - begin;
}
return stats;
} | pushq %rbx
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x28(%rdi)
movups 0x90(%rsi), %xmm0
movups %xmm0, (%rdi)
movq 0xa0(%rsi), %rcx
movq %rcx, 0x10(%rdi)
movq (%rsi), %rcx
movq %rcx, 0x20(%rdi)
movq 0x10(%rsi), %rcx
movabsq $-0x20, %rdi
xorl %edx, %edx
testq %rdi, %rdi
je 0x92dd3
movq 0x30(%rsi,%rdi), %r8
movq 0x38(%rsi,%rdi), %r9
movq %r9, %r10
subq %r8, %r10
movq 0x58(%rsi,%rdi), %r11
movq 0x50(%rsi,%rdi), %rbx
addq %r11, %rdx
addq %r10, %rdx
subq %rbx, %rdx
subq %rcx, %r8
movq %r8, 0x48(%rax,%rdi)
subq %rcx, %r9
movq %r9, 0x50(%rax,%rdi)
subq %rcx, %rbx
movq %rbx, 0x68(%rax,%rdi)
subq %rcx, %r11
movq %r11, 0x70(%rax,%rdi)
addq $0x10, %rdi
jmp 0x92d85
movq %rdx, 0x18(%rax)
popq %rbx
retq
| /binji[P]binjgb/src/rewind.c |
write_varint | static u8* write_varint(u32 value, u8* dst_begin, u8* dst_max_end) {
u8* dst = dst_begin;
if (value < 0x80) {
CHECK_WRITE(1, dst, dst_max_end);
*dst++ = (u8)value;
} else if (value < 0x4000) {
CHECK_WRITE(2, dst, dst_max_end);
*dst++ = 0x80 | (value & 0x7f);
*dst++ = (value >> 7) & 0x7f;
} else {
/* If this fires there is a run of 2Mib. In the current EmulatorState this
* is impossible. */
assert(value < 0x200000);
CHECK_WRITE(3, dst, dst_max_end);
*dst++ = 0x80 | (value & 0x7f);
*dst++ = 0x80 | ((value >> 7) & 0x7f);
*dst++ = (value >> 14) & 0x7f;
}
return dst;
} | cmpl $0x7f, %edi
ja 0x92de9
leaq 0x1(%rsi), %rax
cmpq %rdx, %rax
ja 0x92e19
jmp 0x92e3e
cmpl $0x3fff, %edi # imm = 0x3FFF
ja 0x92e08
leaq 0x2(%rsi), %rax
cmpq %rdx, %rax
ja 0x92e19
pushq $0x7
popq %rcx
pushq $0x1
popq %r9
movl %edi, %edx
movq %rsi, %r8
jmp 0x92e33
cmpl $0x200000, %edi # imm = 0x200000
jae 0x92e42
leaq 0x3(%rsi), %rax
cmpq %rdx, %rax
jbe 0x92e1c
xorl %eax, %eax
retq
movl %edi, %ecx
orb $-0x80, %cl
leaq 0x1(%rsi), %r8
movb %cl, (%rsi)
movl %edi, %edx
shrl $0x7, %edx
pushq $0xe
popq %rcx
pushq $0x2
popq %r9
orb $-0x80, %dl
addq %r9, %rsi
movb %dl, (%r8)
shrl %cl, %edi
movb %dil, (%rsi)
retq
pushq %rax
leaq 0x28dd2(%rip), %rdi # 0xbbc1c
leaq 0x28c1e(%rip), %rsi # 0xbba6f
leaq 0x28dd5(%rip), %rcx # 0xbbc2d
movl $0x85, %edx
callq 0x24110
| /binji[P]binjgb/src/rewind.c |
Debugger::TiledataWindow::CalculateAutoObjPaletteIndex() | void Debugger::TiledataWindow::CalculateAutoObjPaletteIndex() {
ObjSize obj_size = emulator_get_obj_size(d->e);
for (int obj_index = 0; obj_index < 40; ++obj_index) {
Obj obj = emulator_get_obj(d->e, obj_index);
bool visible = static_cast<bool>(obj_is_visible(&obj));
if (visible) {
int tile_index = obj.tile;
int pal_index = 0;
if (d->is_cgb) {
if (obj.bank) {
tile_index += 0x180;
}
pal_index = 9 + obj.cgb_palette;
} else if (d->is_sgb) {
pal_index = 5 + obj.palette;
} else {
pal_index = 2 + obj.palette;
}
if (obj_size == OBJ_SIZE_8X16) {
tile_palette_index[tile_index & ~1] = pal_index;
tile_palette_index[tile_index | 1] = pal_index;
} else {
tile_palette_index[tile_index] = pal_index;
}
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x88(%rax), %rdi
callq 0x85e2c
movl %eax, %ebp
xorl %r14d, %r14d
leaq 0x4(%rsp), %r15
cmpl $0x28, %r14d
je 0x9c893
movq (%rbx), %rax
movq 0x88(%rax), %rsi
movq %r15, %rdi
movl %r14d, %edx
callq 0x85e33
movq %r15, %rdi
callq 0x85e62
testl %eax, %eax
je 0x9c88b
movzbl 0x6(%rsp), %eax
movq (%rbx), %rdx
cmpb $0x1, 0xc0c0(%rdx)
jne 0x9c859
leal 0x180(%rax), %edx
cmpb $0x0, 0x15(%rsp)
cmovel %eax, %edx
movb 0x16(%rsp), %cl
addb $0x9, %cl
movl %edx, %eax
jmp 0x9c86e
movb 0x14(%rsp), %cl
cmpb $0x1, 0xc0c1(%rdx)
jne 0x9c86b
addb $0x5, %cl
jmp 0x9c86e
addb $0x2, %cl
cmpl $0x1, %ebp
jne 0x9c882
movl %eax, %edx
andl $-0x2, %edx
movb %cl, 0x14c(%rbx,%rdx)
orl $0x1, %eax
movl %eax, %eax
movb %cl, 0x14c(%rbx,%rax)
incl %r14d
jmp 0x9c804
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /binji[P]binjgb/src/debugger/tiledata-window.cc |
select_wrapper | int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset. IOW Winsock
* select() can not be used to sleep without a single fd_set.
*/
if(!nfds) {
Sleep((1000*tv->tv_sec) + (DWORD)(((double)tv->tv_usec)/1000.0));
return 0;
}
#endif
return select(nfds, rd, wr, exc, tv);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x3255
callq 0x2030
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3270
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x20e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| /nomaster[P]curl/tests/libtest/first.c |
main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour by the C library in order to test for undesired side
* effects that could cause in libcurl.
*/
#ifdef HAVE_SETLOCALE
setlocale(LC_ALL, "");
#endif
if(argc< 2) {
fprintf(stderr, "Pass URL as argument please\n");
return 1;
}
test_argc = argc;
test_argv = argv;
if(argc>2)
libtest_arg2 = argv[2];
if(argc>3)
libtest_arg3 = argv[3];
URL = argv[1]; /* provide this to the rest */
fprintf(stderr, "URL: %s\n", URL);
result = test(URL);
#ifdef USE_NSS
if(PR_Initialized())
/* prevent valgrind from reporting possibly lost memory (fd cache, ...) */
PR_Cleanup();
#endif
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x3398
movl $0x6, %edi
leaq 0xead(%rip), %rsi # 0x4251
callq 0x20b0
cmpl $0x2, -0x8(%rbp)
jge 0x33d0
movq 0x2c2a(%rip), %rax # 0x5fe0
movq (%rax), %rdi
leaq 0xff2(%rip), %rsi # 0x43b2
movb $0x0, %al
callq 0x2120
movl $0x1, -0x4(%rbp)
jmp 0x3448
movl -0x8(%rbp), %eax
movl %eax, 0x2fa3(%rip) # 0x637c
movq -0x10(%rbp), %rax
movq %rax, 0x2f9c(%rip) # 0x6380
cmpl $0x2, -0x8(%rbp)
jle 0x33f9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2d17(%rip) # 0x6110
cmpl $0x3, -0x8(%rbp)
jle 0x340e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x2d0a(%rip) # 0x6118
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x2bbf(%rip), %rax # 0x5fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0xfa0(%rip), %rsi # 0x43cf
movb $0x0, %al
callq 0x2120
movq -0x18(%rbp), %rdi
callq 0x22c0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /nomaster[P]curl/tests/libtest/first.c |
curlx_uztosi | int curlx_uztosi(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SINT);
return (int)(uznum & (size_t) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x361a
movq -0x8(%rbp), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /nomaster[P]curl/lib/warnless.c |
curlx_uztoui | unsigned int curlx_uztoui(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT(uznum <= (size_t) CURL_MASK_UINT);
#endif
return (unsigned int)(uznum & (size_t) CURL_MASK_UINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x365a
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| /nomaster[P]curl/lib/warnless.c |
curlx_sltoui | unsigned int curlx_sltoui(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_UINT);
#endif
return (unsigned int)(slnum & (long) CURL_MASK_UINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x369a
jmp 0x369c
jmp 0x369e
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x8(%rbp), %rax
popq %rbp
retq
nop
| /nomaster[P]curl/lib/warnless.c |
curlx_uztosz | ssize_t curlx_uztosz(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T);
return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x36da
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| /nomaster[P]curl/lib/warnless.c |
curlx_uitouc | unsigned char curlx_uitouc(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_UCHAR);
return (unsigned char) (uinum & (unsigned int) CURL_MASK_UCHAR);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
jmp 0x3759
movl -0x4(%rbp), %eax
andl $0xff, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /nomaster[P]curl/lib/warnless.c |
curlx_sitouz | size_t curlx_sitouz(int sinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sinum >= 0);
return (size_t) sinum;
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
jmp 0x3799
movslq -0x4(%rbp), %rax
popq %rbp
retq
| /nomaster[P]curl/lib/warnless.c |
CheckCin() | bool CheckCin() {
if (std::cin.fail()) {
std::cin.clear();
std::cin.ignore(32767, '\n');
return false;
}
return true;
} | pushq %rbx
movq 0x681c(%rip), %rdi # 0x8fe0
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x20(%rdi,%rax), %ebx
testb $0x5, %bl
je 0x27f4
addq %rax, %rdi
xorl %esi, %esi
callq 0x22b0
movq 0x67fb(%rip), %rdi # 0x8fe0
movl $0x7fff, %esi # imm = 0x7FFF
movl $0xa, %edx
callq 0x2110
testb $0x5, %bl
sete %al
popq %rbx
retq
| /morozov312[P]SaodCourse/tools.hpp |
Tree::search(int, Vertex*) | vector<record> search(int key, Vertex *root) {
vector<record> tempVector;
if (!root) return tempVector;
if (key < root->data[0].year)
return search(key, root->ptrLeft);
else if (key > root->data[0].year)
return search(key, root->ptrRight);
return root->data;
} | pushq %rbx
movq %rdi, %rbx
testq %rcx, %rcx
je 0x37ac
movq (%rcx), %rax
movswl 0x3c(%rax), %eax
cmpl %edx, %eax
jle 0x37a4
movq 0x20(%rcx), %rcx
jmp 0x378e
jge 0x37bc
movq 0x18(%rcx), %rcx
jmp 0x378e
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x37c7
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x458e
movq %rbx, %rax
popq %rbx
retq
| /morozov312[P]SaodCourse/tree.hpp |
Encode::Encode(List&) | explicit Encode(List &list) {
Node **listIndexArr = list.getIndexArray();
int listSize = list.getIndexArraySize();
for (int i = 0; i < listSize; ++i) {
string tmpStr;
for (int j = 0; listIndexArr[i]->data.author[j] != '\0'; j++) {
m_data.push_back(listIndexArr[i]->data.author[j]);
}
for (int j = 0; listIndexArr[i]->data.title[j] != '\0'; j++) {
m_data.push_back(listIndexArr[i]->data.title[j]);
}
for (int j = 0; listIndexArr[i]->data.publishingHouse[j] != '\0'; j++) {
m_data.push_back(listIndexArr[i]->data.publishingHouse[j]);
}
tmpStr = to_string(listIndexArr[i]->data.year);
for (auto &j : tmpStr) {
m_data.push_back(j);
}
tmpStr = to_string(listIndexArr[i]->data.qtyPages);
for (auto &j : tmpStr) {
m_data.push_back(j);
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x40(%rdi)
movslq 0x10(%rsi), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
jle 0x3af5
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x58(%rsp)
leaq 0x30(%rdi), %r15
movq 0x20(%rsi), %r13
xorl %r12d, %r12d
movq %r15, 0x8(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
movq (%r13,%r12,8), %rdx
movb 0x8(%rdx), %al
testb %al, %al
je 0x387d
addq $0x8, %rdx
movl $0x9, %r14d
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x3862
movb %al, (%rsi)
incq 0x38(%rbx)
jmp 0x386a
movq %r15, %rdi
callq 0x4ca8
movq (%r13,%r12,8), %rdx
movb (%rdx,%r14), %al
addq %r14, %rdx
incq %r14
testb %al, %al
jne 0x3850
movq (%r13,%r12,8), %rdx
movb 0x14(%rdx), %al
testb %al, %al
je 0x38c0
addq $0x14, %rdx
movl $0x15, %r14d
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x38a5
movb %al, (%rsi)
incq 0x38(%rbx)
jmp 0x38ad
movq %r15, %rdi
callq 0x4ca8
movq (%r13,%r12,8), %rdx
movb (%rdx,%r14), %al
addq %r14, %rdx
incq %r14
testb %al, %al
jne 0x3893
movq (%r13,%r12,8), %rdx
movb 0x34(%rdx), %al
testb %al, %al
je 0x3903
addq $0x34, %rdx
movl $0x35, %r14d
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x38e8
movb %al, (%rsi)
incq 0x38(%rbx)
jmp 0x38f0
movq %r15, %rdi
callq 0x4ca8
movq (%r13,%r12,8), %rdx
movb (%rdx,%r14), %al
addq %r14, %rdx
incq %r14
testb %al, %al
jne 0x38d6
movq (%r13,%r12,8), %rax
movswl 0x44(%rax), %r14d
movl %r14d, %ebp
negl %ebp
cmovsl %r14d, %ebp
movl $0x1, %eax
cmpl $0xa, %ebp
jb 0x3945
movl $0x2, %eax
cmpl $0x64, %ebp
jb 0x3945
movl $0x3, %eax
cmpl $0x3e8, %ebp # imm = 0x3E8
jb 0x3945
cmpl $0x2710, %ebp # imm = 0x2710
movl $0x5, %eax
sbbl $0x0, %eax
shrl $0x1f, %r14d
movq %rax, 0x10(%rsp)
leal (%rax,%r14), %esi
leaq 0x48(%rsp), %r15
movq %r15, 0x38(%rsp)
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movl $0x2d, %edx
callq 0x21f0
movl %r14d, %edi
addq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %ebp, %edx
callq 0x4d9a
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x2210
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x39ab
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x20(%rsp), %rbp
testq %rbp, %rbp
movq 0x8(%rsp), %r15
je 0x39e7
movq 0x18(%rsp), %r14
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x39d4
movb (%r14), %al
movb %al, (%rsi)
incq 0x38(%rbx)
jmp 0x39df
movq %r15, %rdi
movq %r14, %rdx
callq 0x4ca8
incq %r14
decq %rbp
jne 0x39bf
movq (%r13,%r12,8), %rax
movswl 0x46(%rax), %r14d
movl %r14d, %ebp
negl %ebp
cmovsl %r14d, %ebp
movl $0x1, %eax
cmpl $0xa, %ebp
jb 0x3a29
movl $0x2, %eax
cmpl $0x64, %ebp
jb 0x3a29
movl $0x3, %eax
cmpl $0x3e8, %ebp # imm = 0x3E8
jb 0x3a29
cmpl $0x2710, %ebp # imm = 0x2710
movl $0x5, %eax
sbbl $0x0, %eax
shrl $0x1f, %r14d
movq %rax, 0x10(%rsp)
leal (%rax,%r14), %esi
leaq 0x48(%rsp), %r15
movq %r15, 0x38(%rsp)
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movl $0x2d, %edx
callq 0x21f0
movl %r14d, %edi
addq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %ebp, %edx
callq 0x4d9a
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x2210
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x3a8f
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x20(%rsp), %rbp
testq %rbp, %rbp
movq 0x8(%rsp), %r15
je 0x3acb
movq 0x18(%rsp), %r14
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x3ab8
movb (%r14), %al
movb %al, (%rsi)
incq 0x38(%rbx)
jmp 0x3ac3
movq %r15, %rdi
movq %r14, %rdx
callq 0x4ca8
incq %r14
decq %rbp
jne 0x3aa3
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x3ae7
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21d0
incq %r12
cmpq 0x60(%rsp), %r12
jne 0x3822
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b06
movq %rax, %r12
movq 0x8(%rsp), %r15
jmp 0x3b1b
jmp 0x3b18
jmp 0x3b18
jmp 0x3b18
jmp 0x3b18
movq %rax, %r12
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x3b37
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21d0
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3b4b
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x58(%rsp), %rdi
callq 0x4c5a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3b69
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r12, %rdi
callq 0x2300
nop
| /morozov312[P]SaodCourse/encode.hpp |
Encode::encodeFano() | void encodeFano() {
calcProbabilities();
m_matrix.resize(m_probabilities.size());
quickSortProbability(0, (int) m_probabilities.size() - 1);
algorithmFano(0, (int) m_probabilities.size() - 1);
output();
} | pushq %rbx
movq %rdi, %rbx
callq 0x4e08
leaq 0x18(%rbx), %rdi
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x3, %rsi
callq 0x4f72
movq 0x8(%rbx), %rdx
subq (%rbx), %rdx
shrq $0x3, %rdx
decl %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4fae
movq 0x8(%rbx), %rdx
subq (%rbx), %rdx
shrq $0x3, %rdx
decl %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x505e
movq %rbx, %rdi
popq %rbx
jmp 0x5144
| /morozov312[P]SaodCourse/encode.hpp |
List::binarySearch(char*) | int binarySearch(char *key) {
if (!this->m_sorted) {
cout << "List doesn't sorted" << endl;
return -1;
}
Node **arr = m_indexArray;
const int keySize = 3;
int mid, left = 0, right = m_listSize - 1;
while (left < right) {
mid = (left + right) / 2;
if (strncmp(arr[mid]->data.publishingHouse, key, keySize) < 0) {
left = mid + 1;
} else {
right = mid;
}
}
if (strncmp(arr[right]->data.publishingHouse, key, keySize) == 0) {
return right;
} else {
return -1;
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x0, 0x28(%rdi)
je 0x3c78
movq %rsi, %rbx
movq 0x20(%rdi), %r15
movl 0x10(%rdi), %eax
leal -0x1(%rax), %r14d
cmpl $0x2, %eax
jl 0x3c55
xorl %r12d, %r12d
leal (%r14,%r12), %r13d
shrl %r13d
movq (%r15,%r13,8), %rdi
addq $0x34, %rdi
movl $0x3, %edx
movq %rbx, %rsi
callq 0x20b0
testl %eax, %eax
js 0x3c4a
movl %r13d, %r14d
jmp 0x3c50
incl %r13d
movl %r13d, %r12d
cmpl %r14d, %r12d
jl 0x3c25
movslq %r14d, %r14
movq (%r15,%r14,8), %rdi
addq $0x34, %rdi
movl $0x3, %edx
movq %rbx, %rsi
callq 0x20b0
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
orl %ecx, %r14d
jmp 0x3cc0
movq 0x5349(%rip), %rbx # 0x8fc8
leaq 0x29cb(%rip), %rsi # 0x6651
movl $0x13, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2130
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movl %r14d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /morozov312[P]SaodCourse/list.hpp |
Tree::destroyRecursive(Vertex**) | void destroyRecursive(Vertex **root) {
if (*root) {
destroyRecursive(&((*root)->ptrLeft));
destroyRecursive(&((*root)->ptrRight));
delete *root;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x3d28
movq %rdi, %r14
addq $0x20, %rsi
callq 0x3cce
movq (%rbx), %rsi
addq $0x18, %rsi
movq %r14, %rdi
callq 0x3cce
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x3d28
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3d14
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movl $0x30, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /morozov312[P]SaodCourse/tree.hpp |
List::printPage(int) | int printPage(int currIndex) {
for (int i = 0; i < m_pageSize; ++i, currIndex++) {
int displayIndex = currIndex + 1 + this->m_foundIndex;
try {
if (currIndex >= m_listSize)
throw std::range_error("Out of range");
} catch (std::range_error &e) {
break;
}
cout.width(numbersOutWidth);
cout << displayIndex;
cout.width(sizeof(m_head->data.author));
cout << (m_indexArray[currIndex]->data).author;
cout.width(sizeof(m_head->data.title));
cout << (m_indexArray[currIndex]->data).title;
cout.width(sizeof(m_head->data.publishingHouse));
cout << (m_indexArray[currIndex]->data).publishingHouse;
cout.width(numbersOutWidth);
cout << (m_indexArray[currIndex]->data).year;
cout.width(numbersOutWidth);
cout << (m_indexArray[currIndex]->data).qtyPages;
cout << endl;
}
return currIndex;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
cmpl $0x0, 0x14(%rdi)
jle 0x3f69
movq %rdi, %r14
movslq %ebx, %rbx
leal 0x1(%rbx), %eax
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
movq 0x520d(%rip), %r15 # 0x8fc8
movslq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %rbx
jge 0x3f08
movq 0x8(%rsp), %rax
leal (%rax,%rbp), %esi
addl 0x18(%r14), %esi
movq (%r15), %rax
movq -0x18(%rax), %rax
movl $0x6, %r13d
movq %r13, 0x10(%r15,%rax)
movq %r15, %rdi
callq 0x22f0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%r15,%rax)
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %r12
addq $0x8, %r12
movq %r12, %rdi
callq 0x20a0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x21e0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x20, 0x10(%r15,%rax)
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %r12
addq $0x14, %r12
movq %r12, %rdi
callq 0x20a0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x21e0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x10, 0x10(%r15,%rax)
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %r12
addq $0x34, %r12
movq %r12, %rdi
callq 0x20a0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x21e0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%r15,%rax)
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %rax
movswl 0x44(%rax), %esi
movq %r15, %rdi
callq 0x2190
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%r15,%rax)
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %rax
movswl 0x46(%rax), %esi
movq %r15, %rdi
callq 0x2190
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2130
cmpq 0x10(%rsp), %rbx
jge 0x3f69
incl %ebp
incq %rbx
cmpl 0x14(%r14), %ebp
jl 0x3dbb
jmp 0x3f69
movl $0x10, %edi
callq 0x20d0
movq %rax, %r13
movq %rax, %rdi
leaq 0x25c9(%rip), %rsi # 0x64e8
callq 0x22d0
movq %r13, %rdi
movq 0x50a2(%rip), %rsi # 0x8fd0
movq 0x508b(%rip), %rdx # 0x8fc0
callq 0x22c0
jmp 0x3f82
movq %rdx, (%rsp)
movq %rax, %r12
jmp 0x3f54
movq %rdx, (%rsp)
movq %rax, %r12
movq %r13, %rdi
callq 0x2150
cmpl $0x1, (%rsp)
jne 0x3f7a
movq %r12, %rdi
callq 0x2090
callq 0x22a0
jmp 0x3ef0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x2300
| /morozov312[P]SaodCourse/list.hpp |
List::printPageByNum(int) | int printPageByNum(int currIndex) {
cout << "Enter page number: ";
int pageNumber;
cin >> pageNumber;
CheckCin();
if (pageNumber <= 0 || pageNumber > m_listSize / m_pageSize) {
cout << "It is impossible to read a page with that number!" << endl;
return currIndex;
} else {
currIndex = (pageNumber - 1) * m_pageSize;
currIndex = printPage(currIndex);
}
return currIndex;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movq 0x4eb0(%rip), %r14 # 0x8fc8
leaq 0x244b(%rip), %rsi # 0x656a
movl $0x13, %edx
movq %r14, %rdi
callq 0x21e0
movq 0x4ead(%rip), %rdi # 0x8fe0
leaq 0x4(%rsp), %r12
movq %r12, %rsi
callq 0x2100
callq 0x27bc
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x415c
movl 0x10(%r15), %eax
movl 0x14(%r15), %esi
cltd
idivl %esi
cmpl %eax, %ecx
jle 0x4199
leaq 0x241b(%rip), %rsi # 0x657e
movl $0x31, %edx
movq %r14, %rdi
callq 0x21e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2130
jmp 0x41a8
decl %ecx
imull %ecx, %esi
movq %r15, %rdi
callq 0x3d8a
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /morozov312[P]SaodCourse/list.hpp |
Tree::createWeightArray() | void createWeightArray() {
quickSort(0, m_queueIndexArraySize - 1);
int currWeight = 1;
for (int i = 0; i < m_queueIndexArraySize; ++i) {
if ((i != m_queueIndexArraySize - 1) && (m_queueIndexArray[i]->data.year == m_queueIndexArray[i + 1]->data.year)) {
currWeight++;
int j = i + 1;
while ((j != m_queueIndexArraySize - 1) && (m_queueIndexArray[j]->data.year == m_queueIndexArray[j + 1]->data.year)) {
currWeight++;
j++;
}
}
m_weightArray.push_back(currWeight);
i += currWeight - 1;
currWeight = 1;
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %edx
decl %edx
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x4612
movl $0x1, 0x4(%rsp)
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0x4298
leaq 0x10(%rbx), %r14
leaq 0x4(%rsp), %r15
leal -0x1(%rax), %ecx
cmpl %ecx, %r12d
je 0x425a
movq (%rbx), %rdi
movslq %r12d, %rcx
movq (%rdi,%rcx,8), %rdx
movq 0x8(%rdi,%rcx,8), %rcx
movzwl 0x44(%rdx), %edx
cmpw 0x44(%rcx), %dx
jne 0x425a
leal 0x1(%r12), %edx
movl 0x4(%rsp), %ecx
movslq %edx, %rsi
movl %r12d, %edx
notl %edx
addl %eax, %edx
addl %ecx, %edx
movslq %eax, %r8
leaq (%rdi,%rsi,8), %rax
addq $0x8, %rax
notq %rsi
addq %r8, %rsi
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x4256
movq -0x8(%rax,%rdi,8), %r8
movq (%rax,%rdi,8), %r9
movzwl 0x44(%r8), %r8d
incq %rdi
cmpw 0x44(%r9), %r8w
je 0x4235
addl %edi, %ecx
movl %ecx, %edx
movl %edx, 0x4(%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0x4274
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rbx)
jmp 0x427f
movq %r14, %rdi
movq %r15, %rdx
callq 0x46ae
addl 0x4(%rsp), %r12d
movl $0x1, 0x4(%rsp)
movl 0x8(%rbx), %eax
cmpl %eax, %r12d
jl 0x41ec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /morozov312[P]SaodCourse/tree.hpp |
Tree::reverseQuickSort(int, int) | void reverseQuickSort(int L, int R) {
int i = L;
int j = R;
int temp = m_weightArray[(i + j) / 2];
while (i <= j) {
while (m_weightArray[i] > temp) {
i++;
}
while (m_weightArray[j] < temp) {
j--;
}
if (i <= j) {
swap(m_weightArray[i], m_weightArray[j]);
swap(m_vectorArray[i], m_vectorArray[j]);
i++;
j--;
}
}
if (L < j) {
reverseQuickSort(L, j);
}
if (i < R) {
reverseQuickSort(i, R);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, (%rsp)
movl %ebx, %edx
movl %esi, %ebp
cmpl %ebx, %esi
jg 0x4495
leal (%rbx,%rsi), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movslq %ecx, %rcx
movq (%rsp), %rdx
movq 0x10(%rdx), %rax
movl (%rax,%rcx,4), %ecx
movq 0x28(%rdx), %rdi
leaq -0x8(%rdi), %r8
addq $0x28, %rdi
movl %esi, %ebp
movl %ebx, %edx
movslq %ebp, %r11
leaq (%r11,%r11,2), %r9
decq %r11
leaq (%r8,%r9,8), %r10
movl %ebp, %r9d
movl 0x4(%rax,%r11,4), %r15d
incq %r11
addq $0x18, %r10
incl %r9d
cmpl %ecx, %r15d
jg 0x440e
leal -0x1(%r9), %ebp
movslq %edx, %r13
leaq (,%r13,2), %r14
addq %r13, %r14
incq %r13
leaq (%rdi,%r14,8), %r12
movl -0x4(%rax,%r13,4), %r14d
decq %r13
addq $-0x18, %r12
decl %edx
cmpl %ecx, %r14d
jl 0x443b
cmpq %r13, %r11
jle 0x4457
incl %edx
jmp 0x448d
movl %r14d, (%rax,%r11,4)
movl %r15d, (%rax,%r13,4)
movups -0x10(%r10), %xmm0
movq (%r10), %r11
movq -0x10(%r12), %r14
movq %r14, -0x10(%r10)
movq -0x8(%r12), %r14
movq %r14, -0x8(%r10)
movq (%r12), %r14
movq %r14, (%r10)
movups %xmm0, -0x10(%r12)
movq %r11, (%r12)
movl %r9d, %ebp
cmpl %edx, %ebp
jle 0x43fd
cmpl %esi, %edx
jle 0x44a2
movq (%rsp), %rdi
callq 0x43b6
movl %ebp, %esi
cmpl %ebx, %ebp
jl 0x43c7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /morozov312[P]SaodCourse/tree.hpp |
Tree::addDoubleIndirection(std::vector<record, std::allocator<record>>, Vertex**, int) | void addDoubleIndirection(vector<record> key, Vertex **root, int weightPos) {
Vertex **head_ptr = root;
while (*head_ptr) {
if (key[0].year < (*head_ptr)->data[0].year) {
head_ptr = &((*head_ptr)->ptrLeft);
} else if (key[0].year > (*head_ptr)->data[0].year) {
head_ptr = &((*head_ptr)->ptrRight);
} else {
cout << "Element is already in the array" << endl;
break;
}
}
if (*head_ptr == nullptr) {
*head_ptr = new Vertex;
(*head_ptr)->data = key;
(*head_ptr)->weight = m_weightArray[weightPos];
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq (%rdx), %rax
testq %rax, %rax
je 0x4547
movq (%r12), %rcx
movzwl 0x3c(%rcx), %ecx
movq (%rax), %rsi
movl $0x20, %edx
cmpw 0x3c(%rsi), %cx
jl 0x44f5
movl $0x18, %edx
jle 0x4504
leaq (%rax,%rdx), %r14
movq (%rax,%rdx), %rax
testq %rax, %rax
jne 0x44e0
jmp 0x4547
movq 0x4abd(%rip), %r13 # 0x8fc8
leaq 0x20b8(%rip), %rsi # 0x65ca
movl $0x1f, %edx
movq %r13, %rdi
callq 0x21e0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2130
cmpq $0x0, (%r14)
jne 0x4583
movl $0x30, %edi
callq 0x21c0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x1c(%rax)
movq %rax, (%r14)
movq %rax, %rdi
movq %r12, %rsi
callq 0x4b84
movslq %ebx, %rax
movq 0x10(%r15), %rcx
movl (%rcx,%rax,4), %eax
movq (%r14), %rcx
movl %eax, 0x28(%rcx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /morozov312[P]SaodCourse/tree.hpp |
Tree::quickSort(int, int) | void quickSort(int L, int R) {
int i = L;
int j = R;
Node temp = *m_queueIndexArray[(i + j) / 2];
while (i <= j) {
while ((*m_queueIndexArray[i]).data.year < temp.data.year) {
i++;
}
while ((*m_queueIndexArray[j]).data.year > temp.data.year) {
j--;
}
if (i <= j) {
swapNodes(&m_queueIndexArray[i], &m_queueIndexArray[j]);
i++;
j--;
}
}
if (L < j) {
quickSort(L, j);
}
if (i < R) {
quickSort(i, R);
}
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movl %ebx, %edx
movl %esi, %ebp
cmpl %ebx, %esi
jg 0x4692
movq (%r14), %rax
leal (%rbx,%rsi), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
movzwl 0x44(%rax), %eax
movl %esi, %ebp
movl %ebx, %edx
movq (%r14), %rcx
movslq %ebp, %rdi
decq %rdi
movl %ebp, %r8d
movq 0x8(%rcx,%rdi,8), %r9
incq %rdi
incl %r8d
cmpw %ax, 0x44(%r9)
jl 0x464d
leal -0x1(%r8), %ebp
movslq %edx, %r10
incq %r10
movq -0x8(%rcx,%r10,8), %r11
decq %r10
decl %edx
cmpw %ax, 0x44(%r11)
jg 0x4669
cmpq %r10, %rdi
jle 0x4683
incl %edx
jmp 0x468e
movq %r11, (%rcx,%rdi,8)
movq %r9, (%rcx,%r10,8)
movl %r8d, %ebp
cmpl %edx, %ebp
jle 0x4641
cmpl %esi, %edx
jle 0x469e
movq %r14, %rdi
callq 0x4612
movl %ebp, %esi
cmpl %ebx, %ebp
jl 0x461b
popq %rbx
popq %r14
popq %rbp
retq
nop
| /morozov312[P]SaodCourse/tree.hpp |
Encode::calcProbabilities() | void calcProbabilities() {
sort(m_data.begin(), m_data.end());
vector<char> tmp;
unique_copy(m_data.begin(), m_data.end(), back_inserter(tmp));
for (auto &i : tmp) {
int countElements = count(m_data.begin(), m_data.end(), i);
m_probabilities.push_back((double) countElements / m_data.size());
}
m_data = tmp;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %r14
movq 0x38(%rdi), %r15
cmpq %r15, %r14
je 0x4e4c
movq %r15, %rax
subq %r14, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x550b
movq %r14, %rdi
movq %r15, %rsi
callq 0x55e6
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
cmpq %rsi, %rdi
je 0x4e73
movq %rsp, %rdx
callq 0x5848
movq (%rsp), %r15
movq 0x8(%rsp), %r12
cmpq %r12, %r15
je 0x4f1e
leaq 0x20(%rsp), %r14
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
cmpq %rcx, %rax
je 0x4ebd
movb (%r15), %sil
xorl %edx, %edx
movq %rax, %rdi
xorl %r8d, %r8d
cmpb %sil, (%rdi)
sete %r8b
addq %r8, %rdx
incq %rdi
cmpq %rcx, %rdi
jne 0x4e9f
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
jmp 0x4ec1
xorpd %xmm0, %xmm0
subq %rax, %rcx
movq %rcx, %xmm1
punpckldq 0x116f(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1177(%rip), %xmm1 # 0x6050
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4f07
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4f12
movq %rbx, %rdi
movq %r14, %rdx
callq 0x58c0
incq %r15
cmpq %r12, %r15
jne 0x4e8a
addq $0x30, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5456
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4f43
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4f51
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4f6a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2300
| /morozov312[P]SaodCourse/encode.hpp |
Encode::quickSortProbability(int, int) | void quickSortProbability(int L, int R) {
int i = L;
int j = R;
double temp = m_probabilities[(i + j) / 2];
while (i <= j) {
while (m_probabilities[i] > temp) {
i++;
}
while (m_probabilities[j] < temp) {
j--;
}
if (i <= j) {
swap(m_probabilities[i], m_probabilities[j]);
swap(m_data[i], m_data[j]);
i++;
j--;
}
}
if (L < j) {
quickSortProbability(L, j);
}
if (i < R) {
quickSortProbability(i, R);
}
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movl %ebx, %edx
movl %esi, %ebp
cmpl %ebx, %esi
jg 0x5043
leal (%rbx,%rsi), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movslq %ecx, %rax
movq (%r14), %rcx
movsd (%rcx,%rax,8), %xmm0
movl %esi, %ebp
movl %ebx, %edx
movq (%r14), %rdi
movslq %ebp, %rax
decq %rax
movl %ebp, %ecx
movsd 0x8(%rdi,%rax,8), %xmm1
incq %rax
incl %ecx
ucomisd %xmm0, %xmm1
ja 0x4fe9
leal -0x1(%rcx), %ebp
movslq %edx, %r8
incq %r8
movsd -0x8(%rdi,%r8,8), %xmm2
decq %r8
decl %edx
ucomisd %xmm2, %xmm0
ja 0x5003
cmpq %r8, %rax
jle 0x501e
incl %edx
jmp 0x503f
movsd %xmm2, (%rdi,%rax,8)
movsd %xmm1, (%rdi,%r8,8)
movq 0x30(%r14), %rdi
movb (%rdi,%rax), %r9b
movb (%rdi,%r8), %r10b
movb %r10b, (%rdi,%rax)
movb %r9b, (%rdi,%r8)
movl %ecx, %ebp
cmpl %edx, %ebp
jle 0x4fde
cmpl %esi, %edx
jle 0x504f
movq %r14, %rdi
callq 0x4fae
movl %ebp, %esi
cmpl %ebx, %ebp
jl 0x4fb7
popq %rbx
popq %r14
popq %rbp
retq
| /morozov312[P]SaodCourse/encode.hpp |
Encode::calcMedian(int, int) | int calcMedian(int left, int right) {
long double sumLeft = 0, sumRight = m_probabilities[right];
unsigned long median;
for (int i = left; i < right; ++i) {
sumLeft += m_probabilities[i];
}
median = right;
while (sumLeft >= sumRight) {
--median;
sumLeft -= m_probabilities[median];
sumRight += m_probabilities[median];
}
return (int) median;
} | movl %edx, %eax
movslq %edx, %rcx
movq (%rdi), %rdx
fldl (%rdx,%rcx,8)
fldz
cmpl %ecx, %esi
jge 0x5c6b
fstp %st(0)
movslq %esi, %rsi
fldz
faddl (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x5c60
fucomi %st(1), %st
jae 0x5c79
fstp %st(1)
fstp %st(0)
fldz
fldz
jmp 0x5c91
leaq (%rdx,%rcx,8), %rcx
addq $-0x8, %rcx
fldl (%rcx)
fsubr %st, %st(1)
faddp %st, %st(2)
decl %eax
addq $-0x8, %rcx
fucomi %st(1), %st
jae 0x5c81
fstp %st(1)
fstp %st(0)
retq
| /morozov312[P]SaodCourse/encode.hpp |
main | int main() {
std::vector<std::thread> threads;
obs::signal<void()> sig;
// We need and atomic operator++()
std::atomic<int> counter(0);
for (int i=0; i<100; ++i) {
sig.connect([&](){ ++counter; });
}
for (int i=0; i<100; ++i) {
threads.push_back(
std::thread(
[&](){
for (int i=0; i<100; ++i)
sig();
}));
}
for (auto& thread : threads)
thread.join();
EXPECT_EQ(100*100*100, counter);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x49ab(%rip), %rax # 0x6ce0
leaq 0x48(%rsp), %rbx
movq %rax, -0x8(%rbx)
leaq 0x88(%rsp), %rdi
movups %xmm0, -0x40(%rdi)
movups %xmm0, -0x30(%rdi)
movups %xmm0, -0x20(%rdi)
movups %xmm0, -0x13(%rdi)
callq 0x2150
leaq 0x1c(%rsp), %r14
movl $0x0, (%r14)
movl $0x64, %ebp
leaq 0x49bd(%rip), %r15 # 0x6d30
leaq 0x168(%rip), %r12 # 0x24e2
leaq 0x169(%rip), %r13 # 0x24ea
movl $0x28, %edi
callq 0x2140
movq %r15, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq %r14, 0x8(%rax)
movq %r12, 0x20(%rax)
movq %r13, 0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2e8e
decl %ebp
jne 0x2381
movl $0x64, %ebp
leaq 0x49c8(%rip), %r12 # 0x6d88
leaq 0x40(%rsp), %r13
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %r14
leaq 0x20(%rsp), %r15
movq $0x0, 0x10(%rsp)
movl $0x10, %edi
callq 0x2140
movq %r12, (%rax)
movq %r13, 0x8(%rax)
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2110
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2410
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3058
cmpq $0x0, 0x10(%rsp)
jne 0x24bd
decl %ebp
jne 0x23d4
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %r14
cmpq %r14, %rbx
je 0x2448
movq %rbx, %rdi
callq 0x2190
addq $0x8, %rbx
jmp 0x2435
leaq 0x8(%rsp), %rdi
movl $0xf4240, (%rdi) # imm = 0xF4240
leaq 0x1baa(%rip), %rdx # 0x4004
leaq 0x1c(%rsp), %rsi
movl $0x24, %ecx
callq 0x2541
leaq 0x40(%rsp), %rdi
callq 0x25da
leaq 0x20(%rsp), %rdi
callq 0x269a
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24c2
jmp 0x24c2
jmp 0x24c2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x24aa
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x24c5
cmpq $0x0, 0x10(%rsp)
je 0x24c2
callq 0x2030
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x25da
leaq 0x20(%rsp), %rdi
callq 0x269a
movq %rbx, %rdi
callq 0x21b0
nop
| /dacap[P]observable/tests/count_signals.cpp |
obs::safe_list<obs::slot<void ()>>::push_back(obs::slot<void ()>*) | void push_back(T* value) {
node* n = new node(value);
std::lock_guard<std::mutex> lock(m_mutex_nodes);
if (!m_first)
m_first = m_last = n;
else {
m_last->next = n;
m_last = n;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x28, %edi
callq 0x2140
movq %rax, %r14
movq %r15, (%rax)
movl $0x0, 0x8(%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
callq 0x2100
movq %rax, 0x18(%r14)
movq %r15, 0x20(%r14)
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
jne 0x2eff
leaq 0x30(%rbx), %rax
movq 0x30(%rbx), %rcx
addq $0x10, %rcx
xorl %edx, %edx
cmpq $0x0, 0x28(%rbx)
cmoveq %rax, %rcx
setne %dl
movq %r14, (%rcx)
movq %r14, 0x28(%rbx,%rdx,8)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
movl %eax, %edi
callq 0x20c0
| /dacap[P]observable/./obs/safe_list.h |
Ptex::v2_4::PtexReader::open(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool PtexReader::open(const char* pathArg, Ptex::String& error)
{
AutoMutex locker(readlock);
if (!needToOpen()) return false;
if (!LittleEndian()) {
error = "Ptex library doesn't currently support big-endian cpu's";
return 0;
}
_path = pathArg;
_fp = _io->open(pathArg);
if (!_fp) {
std::string errstr = "Can't open ptex file: ";
errstr += pathArg; errstr += "\n"; errstr += _io->lastError();
error = errstr.c_str();
_ok = 0;
return 0;
}
memset(&_header, 0, sizeof(_header));
readBlock(&_header, HeaderSize);
if (_header.magic != Magic) {
std::string errstr = "Not a ptex file: "; errstr += pathArg;
error = errstr.c_str();
_ok = 0;
closeFP();
return 0;
}
if (_header.version != 1) {
std::stringstream s;
s << "Unsupported ptex file version ("<< _header.version << "): " << pathArg;
error = s.str();
_ok = 0;
closeFP();
return 0;
}
if (!(_header.meshtype == mt_triangle || _header.meshtype == mt_quad)) {
std::stringstream s;
s << "Invalid mesh type (" << _header.meshtype << "): " << pathArg;
error = s.str();
_ok = 0;
closeFP();
return 0;
}
_pixelsize = _header.pixelSize();
_errorPixel.resize(_pixelsize);
// install temp error handler to capture error (to return in error param)
TempErrorHandler tempErr;
PtexErrorHandler* prevErr = _err;
_err = &tempErr;
// read extended header
memset(&_extheader, 0, sizeof(_extheader));
readBlock(&_extheader, PtexUtils::min(uint32_t(ExtHeaderSize), _header.extheadersize));
// compute offsets of various blocks
FilePos pos = HeaderSize + _header.extheadersize;
_faceinfopos = pos; pos += _header.faceinfosize;
_constdatapos = pos; pos += _header.constdatasize;
_levelinfopos = pos; pos += _header.levelinfosize;
_leveldatapos = pos; pos += _header.leveldatasize;
_metadatapos = pos; pos += _header.metadatazipsize;
pos += sizeof(uint64_t); // compatibility barrier
_lmdheaderpos = pos; pos += _extheader.lmdheaderzipsize;
_lmddatapos = pos; pos += _extheader.lmddatasize;
// edit data may not start immediately if additional sections have been added
// use value from extheader if present (and > pos)
_editdatapos = PtexUtils::max(FilePos(_extheader.editdatapos), pos);
// read basic file info
readFaceInfo();
readConstData();
readLevelInfo();
readEditData();
_baseMemUsed = _memUsed;
// restore error handler
_err = prevErr;
// an error occurred while reading the file
if (!_ok) {
error = tempErr.getErrorString();
closeFP();
return 0;
}
AtomicStore(&_needToOpen, false);
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x4400
cmpb $0x0, 0x52(%r14)
je 0x5787
leaq 0x68(%r14), %r13
movq 0x70(%r14), %rbp
movq %r12, %rdi
callq 0x4130
movq %r13, %rdi
xorl %esi, %esi
movq %rbp, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x4440
movq 0x40(%r14), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x10(%rax)
movq %rax, 0x58(%r14)
testq %rax, %rax
je 0x5505
leaq 0x88(%r14), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%r14)
movups %xmm0, 0xa8(%r14)
movups %xmm0, 0x98(%r14)
movups %xmm0, 0x88(%r14)
movq %r14, %rdi
movq %r13, %rsi
movl $0x40, %edx
movl $0x1, %ecx
callq 0x5e66
cmpl $0x78657450, (%r13) # imm = 0x78657450
jne 0x5586
cmpl $0x1, 0x8c(%r14)
jne 0x5605
cmpl $0x2, 0x90(%r14)
jae 0x5672
movl 0x94(%r14), %eax
leaq 0x102e5(%rip), %rcx # 0x15670
movslq (%rcx,%rax,4), %rax
movzwl 0x9c(%r14), %esi
imulq %rax, %rsi
movl %esi, 0x130(%r14)
leaq 0x220(%r14), %rdi
callq 0x888a
leaq 0x18463(%rip), %r13 # 0x1d818
leaq 0x38(%rsp), %r12
movq %r13, -0x18(%r12)
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq 0x48(%r14), %rbp
leaq 0x20(%rsp), %rcx
movq %rcx, 0x48(%r14)
leaq 0xc8(%r14), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0xc8(%r14)
movups %xmm0, 0xd8(%r14)
movq %rax, 0xe8(%r14)
movl 0xa4(%r14), %eax
cmpl $0x28, %eax
movl $0x28, %edx
cmovbl %eax, %edx
movq %r14, %rdi
movl $0x1, %ecx
callq 0x5e66
movl 0xa4(%r14), %eax
movl 0xa8(%r14), %ecx
addl $0x40, %eax
movq %rax, 0xf0(%r14)
addq %rax, %rcx
movq %rcx, 0xf8(%r14)
movl 0xac(%r14), %eax
addq %rcx, %rax
movq %rax, 0x100(%r14)
movl 0xb0(%r14), %ecx
addq %rax, %rcx
movq %rcx, 0x108(%r14)
addq 0xb8(%r14), %rcx
movq %rcx, 0x110(%r14)
movl 0xc0(%r14), %eax
leaq (%rcx,%rax), %rdx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, 0x118(%r14)
movl 0xd0(%r14), %eax
addq %rdx, %rax
addq $0x8, %rax
movq %rax, 0x120(%r14)
addq 0xd8(%r14), %rax
movq 0xe8(%r14), %rcx
cmpq %rax, %rcx
cmovgq %rcx, %rax
movq %rax, 0x128(%r14)
movq %r14, %rdi
callq 0x5ec8
movq %r14, %rdi
callq 0x5fc6
movq %r14, %rdi
callq 0x6068
movq %r14, %rdi
callq 0x613a
movq 0x2b0(%r14), %rax
movq %rax, 0x2a8(%r14)
movq %rbp, 0x48(%r14)
movb 0x51(%r14), %bpl
testb %bpl, %bpl
je 0x57a5
mfence
movb $0x0, 0x52(%r14)
jmp 0x57ba
leaq 0x30(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0xfce3(%rip), %rsi # 0x151f8
leaq 0xfcf2(%rip), %rdx # 0x1520e
leaq 0x20(%rsp), %rdi
callq 0x9c12
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x44c0
leaq 0xfcd5(%rip), %rsi # 0x1520f
leaq 0x20(%rsp), %rdi
callq 0x44c0
movq 0x40(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x44c0
movq 0x20(%rsp), %r12
movq 0x8(%r15), %r13
movq %r12, %rdi
callq 0x4130
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x4440
movb $0x0, 0x51(%r14)
jmp 0x55e5
leaq 0x30(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0xfc7b(%rip), %rsi # 0x15211
leaq 0xfc85(%rip), %rdx # 0x15222
leaq 0x20(%rsp), %rdi
callq 0x9c12
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x44c0
movq 0x20(%rsp), %r12
movq 0x8(%r15), %r13
movq %r12, %rdi
callq 0x4130
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x4440
movb $0x0, 0x51(%r14)
movq %r14, %rdi
callq 0x5bee
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5787
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x5787
leaq 0x20(%rsp), %rdi
callq 0x4210
leaq 0x30(%rsp), %r13
leaq 0xfc08(%rip), %rsi # 0x15223
movl $0x1f, %edx
movq %r13, %rdi
callq 0x4330
movl 0x8c(%r14), %esi
movq %r13, %rdi
callq 0x41e0
movq %rax, %r13
leaq 0xfc02(%rip), %rsi # 0x15243
movl $0x3, %edx
movq %rax, %rdi
callq 0x4330
testq %r12, %r12
je 0x570b
movq %r12, %rdi
callq 0x4130
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4330
jmp 0x5726
leaq 0x20(%rsp), %rdi
callq 0x4210
leaq 0x30(%rsp), %r13
leaq 0xfbbf(%rip), %rsi # 0x15247
movl $0x13, %edx
movq %r13, %rdi
callq 0x4330
movl 0x90(%r14), %esi
movq %r13, %rdi
callq 0x41e0
movq %rax, %r13
leaq 0xfb95(%rip), %rsi # 0x15243
movl $0x3, %edx
movq %rax, %rdi
callq 0x4330
movq %r13, %rdi
movq %r12, %rsi
callq 0x42b0
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x4450
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4380
movq (%r12), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x56fc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movb $0x0, 0x51(%r14)
movq %r14, %rdi
callq 0x5bee
jmp 0x5769
movq (%r13), %rax
movq -0x18(%rax), %rax
movq %r13, %rdi
addq %rax, %rdi
movl 0x20(%r13,%rax), %esi
orl $0x1, %esi
callq 0x4480
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x4450
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4380
movq (%r12), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x575c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movb $0x0, 0x51(%r14)
movq %r14, %rdi
callq 0x5bee
movq 0x18848(%rip), %rsi # 0x1dfb8
leaq 0x20(%rsp), %rdi
callq 0x4230
leaq 0xa0(%rsp), %rdi
callq 0x40f0
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x4240
movl %ebp, %eax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x4180
movq %r14, %rdi
callq 0x5bee
movq %r13, 0x20(%rsp)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x5789
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x5789
jmp 0x5801
jmp 0x57e6
jmp 0x5842
jmp 0x5801
jmp 0x5842
jmp 0x5842
jmp 0x5842
movq %rax, %r14
movq %r13, 0x20(%rsp)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x5845
movq 0x38(%rsp), %rsi
jmp 0x5838
jmp 0x5801
movq %rax, %r14
movq 0x187ad(%rip), %rsi # 0x1dfb8
leaq 0x20(%rsp), %rdi
callq 0x4230
leaq 0xa0(%rsp), %rdi
callq 0x40f0
jmp 0x5845
jmp 0x5826
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5845
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x5845
movq %rax, %r14
movq %rbx, %rdi
callq 0x4240
movq %r14, %rdi
callq 0x4490
nop
| /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_4::PtexReader::readEditMetaData() | void PtexReader::readEditMetaData()
{
// read header
EditMetaDataHeader emdh;
if (!readBlock(&emdh, EditMetaDataHeaderSize)) return;
// record header info for later
_metaedits.push_back(MetaEdit());
MetaEdit& e = _metaedits.back();
e.pos = tell();
e.zipsize = emdh.metadatazipsize;
e.memsize = emdh.metadatamemsize;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movl $0x1, %ecx
callq 0x5e66
testb %al, %al
je 0x6b94
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x1d0(%rbx), %rsi
cmpq 0x1d8(%rbx), %rsi
je 0x6b6b
movups %xmm0, (%rsi)
movq 0x1d0(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x1d0(%rbx)
jmp 0x6b83
leaq 0x1c8(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0xaf1c
movq 0x1d0(%rbx), %rax
movq 0x60(%rbx), %rcx
movq %rcx, -0x10(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, -0x8(%rax)
addq $0x20, %rsp
popq %rbx
retq
| /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_4::PtexReader::readFaceData(long, Ptex::v2_4::FaceDataHeader, Ptex::v2_4::Res, int, Ptex::v2_4::PtexReader::FaceData*&) | void PtexReader::readFaceData(FilePos pos, FaceDataHeader fdh, Res res, int levelid,
FaceData*& face)
{
AutoMutex locker(readlock);
if (face) {
return;
}
// keep new face local until fully initialized
FaceData* newface = 0;
size_t newMemUsed = 0;
seek(pos);
switch (fdh.encoding()) {
case enc_constant:
{
ConstantFace* cf = new ConstantFace(_pixelsize);
newface = cf;
newMemUsed = sizeof(ConstantFace) + _pixelsize;
readBlock(cf->data(), _pixelsize);
if (levelid==0 && _premultiply && _header.hasAlpha())
PtexUtils::multalpha(cf->data(), 1, datatype(),
_header.nchannels, _header.alphachan);
}
break;
case enc_tiled:
{
Res tileres;
readBlock(&tileres, sizeof(tileres));
uint32_t tileheadersize;
readBlock(&tileheadersize, sizeof(tileheadersize));
TiledFace* tf = new TiledFace(this, res, tileres, levelid);
newface = tf;
newMemUsed = tf->memUsed();
readZipBlock(&tf->_fdh[0], tileheadersize, FaceDataHeaderSize * tf->_ntiles);
computeOffsets(tell(), tf->_ntiles, &tf->_fdh[0], &tf->_offsets[0]);
}
break;
case enc_zipped:
case enc_diffzipped:
{
int uw = res.u(), vw = res.v();
int npixels = uw * vw;
int unpackedSize = _pixelsize * npixels;
PackedFace* pf = new PackedFace(res, _pixelsize, unpackedSize);
newface = pf;
newMemUsed = sizeof(PackedFace) + unpackedSize;
bool useNew = unpackedSize > AllocaMax;
char* tmp = useNew ? new char [unpackedSize] : (char*) alloca(unpackedSize);
readZipBlock(tmp, fdh.blocksize(), unpackedSize);
if (fdh.encoding() == enc_diffzipped)
PtexUtils::decodeDifference(tmp, unpackedSize, datatype());
PtexUtils::interleave(tmp, uw * DataSize(datatype()), uw, vw,
pf->data(), uw * _pixelsize,
datatype(), _header.nchannels);
if (levelid==0 && _premultiply && _header.hasAlpha())
PtexUtils::multalpha(pf->data(), npixels, datatype(),
_header.nchannels, _header.alphachan);
if (useNew) delete [] tmp;
}
break;
}
if (!newface) newface = errorData();
AtomicStore(&face, newface);
increaseMemUsed(newMemUsed);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r13
movl %r8d, -0x30(%rbp)
movl %ecx, %r12d
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
addq $0x8, %rdi
movq %rdi, -0x58(%rbp)
callq 0x4400
cmpq $0x0, (%r13)
jne 0x70b0
movl %ebx, -0x38(%rbp)
movl %r12d, -0x2c(%rbp)
movq %r13, -0x68(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x8978
movl -0x38(%rbp), %eax
movl %eax, %r13d
shrl $0x1e, %r13d
leal -0x1(%r13), %eax
cmpl $0x2, %eax
jae 0x6e28
movl -0x2c(%rbp), %ebx
movzbl %bh, %eax
movl $0x1, %edx
movl $0x1, %esi
movl %ebx, %ecx
shll %cl, %esi
movl %eax, %ecx
shll %cl, %edx
movl %edx, -0x4c(%rbp)
movq %r14, %rdx
movl %esi, -0x48(%rbp)
movl %esi, %r14d
shll %cl, %r14d
movq %rdx, -0x60(%rbp)
movl 0x130(%rdx), %r12d
movl $0x18, %edi
callq 0x42d0
movq %rax, %r15
movw %bx, 0x8(%rax)
leaq 0x1681e(%rip), %rax # 0x1d600
movq %rax, (%r15)
movl %r12d, 0xc(%r15)
movl %r14d, -0x44(%rbp)
imull %r14d, %r12d
movslq %r12d, %rdi
movq %rdi, %rbx
callq 0x4030
movq %r15, -0x40(%rbp)
movq %rax, 0x10(%r15)
cmpl $0x4001, %r12d # imm = 0x4001
movq -0x60(%rbp), %r14
jl 0x6fab
movq %rbx, %r15
movq %rbx, %rdi
callq 0x4030
movq %rax, %rbx
jmp 0x6fc2
testl %r13d, %r13d
jne 0x6edd
movl $0x18, %edi
callq 0x42d0
movq %rax, %r13
movslq 0x130(%r14), %r15
movw $0x0, 0x8(%rax)
leaq 0x167ae(%rip), %rax # 0x1d600
movq %rax, (%r13)
movl %r15d, 0xc(%r13)
movq %r15, %rdi
callq 0x4030
movq %rax, 0x10(%r13)
leaq 0x16813(%rip), %rcx # 0x1d680
movq %rcx, (%r13)
movq %r14, %rdi
movq %rax, %rsi
movl %r15d, %edx
movl $0x1, %ecx
callq 0x5e66
addq $0x18, %r15
cmpl $0x0, -0x30(%rbp)
jne 0x7099
cmpb $0x1, 0x50(%r14)
jne 0x7099
movl 0x98(%r14), %r8d
testl %r8d, %r8d
setns %al
movzwl 0x9c(%r14), %ecx
cmpl %ecx, %r8d
setl %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x7099
movq 0x10(%r13), %rdi
movl 0x94(%r14), %edx
movl $0x1, %esi
callq 0xd301
jmp 0x7099
leaq -0x32(%rbp), %rsi
movw $0x0, (%rsi)
movq %r14, %rdi
movl $0x2, %edx
movl $0x1, %ecx
callq 0x5e66
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
movl $0x4, %edx
movl $0x1, %ecx
callq 0x5e66
movl $0x88, %edi
callq 0x42d0
movq %rax, %r13
movzwl -0x32(%rbp), %ecx
movq %rax, %rdi
movq %r14, %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %r8d
callq 0x8bde
movq 0x40(%r13), %r15
movq 0x60(%r13), %r12
subq 0x38(%r13), %r15
movq 0x58(%r13), %rbx
movl -0x50(%rbp), %edx
movl 0x2c(%r13), %ecx
shll $0x2, %ecx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6422
subq %rbx, %r12
shrq $0x2, %r12
leaq (%r12,%r12,2), %rax
movslq 0x2c(%r13), %rcx
testq %rcx, %rcx
je 0x6f9b
movq 0x70(%r13), %rdx
movq 0x58(%r13), %rsi
movq 0x60(%r14), %rdi
shlq $0x3, %rcx
xorl %r8d, %r8d
movq %rdi, (%rdx,%r8)
movl (%rsi), %r9d
andl $0x3fffffff, %r9d # imm = 0x3FFFFFFF
addq %r9, %rdi
addq $0x4, %rsi
addq $0x8, %r8
cmpq %r8, %rcx
jne 0x6f7d
leaq (%r15,%rax,4), %r15
addq $0x88, %r15
jmp 0x7099
movq %rsp, %rax
movq %rbx, %r15
movq %rax, %rbx
leaq 0xf(%r15), %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
movl -0x38(%rbp), %edx
andl $0x3fffffff, %edx # imm = 0x3FFFFFFF
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %ecx
callq 0x6422
cmpl $0x2, %r13d
jne 0x6ff1
movl 0x94(%r14), %edx
movq %rbx, %rdi
movl %r12d, %esi
callq 0xb981
movl 0x94(%r14), %eax
leaq 0xe671(%rip), %rcx # 0x15670
movl (%rcx,%rax,4), %esi
movl -0x2c(%rbp), %edx
movl %edx, %ecx
shll %cl, %esi
movl 0x130(%r14), %r9d
movq -0x40(%rbp), %rcx
movq 0x10(%rcx), %r8
movl %edx, %ecx
shll %cl, %r9d
movzwl 0x9c(%r14), %r10d
movq %rbx, %rdi
movl -0x48(%rbp), %edx
movl -0x4c(%rbp), %ecx
pushq %r10
pushq %rax
callq 0xb5c3
addq $0x10, %rsp
cmpl $0x0, -0x30(%rbp)
jne 0x7080
cmpb $0x1, 0x50(%r14)
jne 0x7080
movl 0x98(%r14), %r8d
testl %r8d, %r8d
setns %al
movzwl 0x9c(%r14), %ecx
cmpl %ecx, %r8d
setl %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x7080
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
movl 0x94(%r14), %edx
movl -0x44(%rbp), %esi
callq 0xd301
addq $0x18, %r15
cmpl $0x4001, %r12d # imm = 0x4001
jl 0x7095
movq %rbx, %rdi
callq 0x43a0
movq -0x40(%rbp), %r13
mfence
movq -0x68(%rbp), %rax
movq %r13, (%rax)
testq %r15, %r15
je 0x70b0
lock
addq %r15, 0x2b0(%r14)
movq -0x58(%rbp), %rdi
callq 0x4240
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x88, %esi
jmp 0x70dc
jmp 0x70fd
movq %rax, %rbx
movl $0x18, %esi
movq %r13, %rdi
jmp 0x70f0
jmp 0x70fd
jmp 0x70fd
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x42e0
jmp 0x7100
jmp 0x70fd
jmp 0x70fd
jmp 0x70fd
movq %rax, %rbx
movq -0x58(%rbp), %rdi
callq 0x4240
movq %rbx, %rdi
callq 0x4490
nop
| /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_4::PtexReader::getData(int, void*, int, Ptex::v2_4::Res) | void PtexReader::getData(int faceid, void* buffer, int stride, Res res)
{
if (!_ok || faceid < 0 || size_t(faceid) >= _header.nfaces) {
PtexUtils::fill(&_errorPixel[0], buffer, stride, res.u(), res.v(), _pixelsize);
return;
}
// note - all locking is handled in called getData methods
int resu = res.u(), resv = res.v();
int rowlen = _pixelsize * resu;
if (stride == 0) stride = rowlen;
PtexPtr<PtexFaceData> d ( getData(faceid, res) );
if (d->isConstant()) {
// fill dest buffer with pixel value
PtexUtils::fill(d->getData(), buffer, stride,
resu, resv, _pixelsize);
}
else if (d->isTiled()) {
// loop over tiles
Res tileres = d->tileRes();
int ntilesu = res.ntilesu(tileres);
int ntilesv = res.ntilesv(tileres);
int tileures = tileres.u();
int tilevres = tileres.v();
int tilerowlen = _pixelsize * tileures;
int tile = 0;
char* dsttilerow = (char*) buffer;
for (int i = 0; i < ntilesv; i++) {
char* dsttile = dsttilerow;
for (int j = 0; j < ntilesu; j++) {
PtexPtr<PtexFaceData> t ( d->getTile(tile++) );
if (t->isConstant())
PtexUtils::fill(t->getData(), dsttile, stride,
tileures, tilevres, _pixelsize);
else
PtexUtils::copy(t->getData(), tilerowlen, dsttile, stride,
tilevres, tilerowlen);
dsttile += tilerowlen;
}
dsttilerow += stride * tilevres;
}
}
else {
PtexUtils::copy(d->getData(), rowlen, buffer, stride, resv, rowlen);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %eax
movl %ecx, %r11d
movq %rdi, %r9
movzwl %ax, %r13d
movl %r13d, %ebp
shrl $0x8, %ebp
testl %esi, %esi
js 0x723f
cmpb $0x0, 0x51(%r9)
je 0x723f
cmpl %esi, 0xa0(%r9)
jbe 0x723f
movq %rdx, 0x8(%rsp)
movl $0x1, %r14d
movl $0x1, %r12d
movl %eax, %ecx
shll %cl, %r12d
movl %ebp, %ecx
shll %cl, %r14d
movl 0x130(%r9), %ebx
movl %eax, %ecx
shll %cl, %ebx
testl %r11d, %r11d
cmovel %ebx, %r11d
movl %r11d, 0x4(%rsp)
movq (%r9), %rcx
movq %r9, 0x18(%rsp)
movq %r9, %rdi
movl %eax, %edx
callq *0xa0(%rcx)
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %rcx
testb %al, %al
je 0x727f
movq %r15, %rdi
callq *0x30(%rcx)
movq 0x18(%rsp), %rcx
movl 0x130(%rcx), %r9d
movq %rax, %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
movl %r12d, %ecx
movl %r14d, %r8d
callq 0xca5e
jmp 0x7442
movl $0x1, %r8d
movl $0x1, %r10d
movl %eax, %ecx
shll %cl, %r10d
movl %ebp, %ecx
shll %cl, %r8d
movq 0x220(%r9), %rdi
movl 0x130(%r9), %r9d
movq %rdx, %rsi
movl %r11d, %edx
movl %r10d, %ecx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xca5e
movq %r15, %rdi
callq *0x38(%rcx)
movq (%r15), %rcx
testb %al, %al
je 0x7423
movq %r15, %rdi
callq *0x40(%rcx)
movl %eax, %edx
movzwl %dx, %eax
shrl $0x8, %eax
movsbl %bpl, %esi
movsbl %al, %edi
movl $0x1, %r8d
movl %edx, %ecx
shll %cl, %r8d
movl %r8d, 0x34(%rsp)
movl $0x1, %r8d
movl %edi, %ecx
shll %cl, %r8d
movl %r8d, 0x14(%rsp)
subl %edi, %esi
movl $0x1, %edi
movq 0x18(%rsp), %rcx
movl 0x130(%rcx), %r8d
movl %edx, %ecx
shll %cl, %r8d
movl %r8d, 0x10(%rsp)
cmpl $0x1f, %esi
je 0x7442
movl $0x1, %r8d
movl %esi, %ecx
shll %cl, %r8d
movsbl %r13b, %esi
movsbl %dl, %ecx
subl %ecx, %esi
movl $0x1, %r9d
movl %esi, %ecx
shll %cl, %r9d
movslq 0x10(%rsp), %r13
movl 0x4(%rsp), %edx
movl %eax, %ecx
shll %cl, %edx
movslq %edx, %rcx
cmpl $0x2, %r9d
cmovll %edi, %r9d
movq %r9, 0x40(%rsp)
cmpl $0x2, %r8d
cmovll %edi, %r8d
xorl %edx, %edx
xorl %r12d, %r12d
movl %r8d, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rcx, 0x38(%rsp)
cmpl $0x1f, %esi
jne 0x7351
movq 0x8(%rsp), %rax
jmp 0x740e
movl %edx, 0x30(%rsp)
movq 0x40(%rsp), %rax
leal (%rax,%r12), %ecx
movl %ecx, 0x2c(%rsp)
movl %eax, %r14d
movq 0x8(%rsp), %rbp
movq (%r15), %rax
movq %r15, %rdi
movl %r12d, %esi
callq *0x48(%rax)
movq %rax, %rbx
movq (%rax), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %rcx
movq 0x30(%rcx), %rcx
testb %al, %al
je 0x73b8
movq %rbx, %rdi
callq *%rcx
movq 0x18(%rsp), %rcx
movl 0x130(%rcx), %r9d
movq %rax, %rdi
movq %rbp, %rsi
movl 0x4(%rsp), %edx
movl 0x34(%rsp), %ecx
movl 0x14(%rsp), %r8d
callq 0xca5e
jmp 0x73d8
movq %rbx, %rdi
callq *%rcx
movq %rax, %rdi
movl 0x10(%rsp), %esi
movq %rbp, %rdx
movl 0x4(%rsp), %ecx
movl 0x14(%rsp), %r8d
movl %esi, %r9d
callq 0xcad9
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
addq %r13, %rbp
incl %r12d
decl %r14d
jne 0x736a
movl 0x2c(%rsp), %eax
movl %eax, %r12d
movq 0x8(%rsp), %rax
movl 0x28(%rsp), %r8d
movl 0x24(%rsp), %esi
movq 0x38(%rsp), %rcx
movl 0x30(%rsp), %edx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
incl %edx
cmpl %r8d, %edx
jne 0x7342
jmp 0x7442
movq %r15, %rdi
callq *0x30(%rcx)
movq %rax, %rdi
movl %ebx, %esi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
movl %r14d, %r8d
movl %ebx, %r9d
callq 0xcad9
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7462
jmp 0x7486
jmp 0x7462
jmp 0x7486
movq %rax, %r14
jmp 0x7473
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %r14, %rdi
callq 0x4490
jmp 0x7486
movq %rax, %rdi
callq 0x522a
| /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Header::Header(std::filesystem::__cxx11::path const&) | Header::Header(const fs::path & path)
: m_fullPath (path)
, m_fileName (path.filename())
, m_id (id++)
{ } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x50(%rdi), %rax
movq %rax, 0x20(%rdi)
movq $0x1, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movl $0x3f800000, 0x40(%rdi) # imm = 0x3F800000
movups %xmm0, 0x48(%rdi)
leaq 0x58(%rdi), %r15
movq %r15, %rdi
callq 0x6c98
leaq 0x80(%rbx), %r12
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x6849
movq 0x20(%r14), %rcx
movl %ecx, %edx
notb %dl
testb $0x3, %dl
je 0x683c
movl %ecx, %edx
andl $0x3, %edx
jne 0x6849
movq (%r14), %rdx
cmpb $0x2f, -0x1(%rdx,%rax)
je 0x6849
testb $0x3, %cl
je 0x6818
xorl %eax, %eax
jmp 0x6821
leaq 0x20(%r14), %rdi
callq 0x6160
leaq -0x30(%rax), %rcx
testb $0x3, 0x20(%r14)
cmovneq %rax, %rcx
cmoveq %rcx, %r14
movl 0x20(%r14), %eax
notl %eax
testb $0x3, %al
jne 0x6849
movq %r12, %rdi
movq %r14, %rsi
callq 0x6c98
jmp 0x6851
movq %r12, %rdi
callq 0x6e68
movzwl 0x69c4(%rip), %eax # 0xd21c
movl %eax, %ecx
incl %ecx
movw %cx, 0x69b9(%rip) # 0xd21c
movw %ax, 0xa8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x6cf8
jmp 0x6889
movq %rax, %r14
leaq 0x20(%rbx), %rdi
callq 0x6e92
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x68a6
movq (%r13), %rsi
incq %rsi
callq 0x6240
movq %r14, %rdi
callq 0x6370
| /Hopson97[P]Conglomerate/src/Header.cpp |
printToFile(std::queue<Node*, std::deque<Node*, std::allocator<Node*>>>) | void printToFile(std::queue<Node*> cl) {
ofstream Nodes;
Nodes.open("Nodes.txt");
cl.pop();
int nodeCount = 1;
while (!cl.empty()) {
int count = 0;
Nodes << std::endl;
Nodes << "Node number: " << nodeCount;
for (auto i : cl.front()->puzzle) {
if (count % 3 == 0)
Nodes << std::endl;
Nodes << i << ' ';
count++;
}
Nodes << std::endl;
Nodes << "Parent: ";
for (auto i : cl.front()->parent->puzzle) {
if (count % 3 == 0)
Nodes << std::endl;
Nodes << i << ' ';
count++;
}
cl.pop();
nodeCount++;
}
Nodes.close();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdi, %rbx
leaq -0x238(%rbp), %r14
movq %r14, %rdi
callq 0x2190
leaq 0x2a61(%rip), %rsi # 0x5016
movq %r14, %rdi
movl $0x10, %edx
callq 0x2040
movq %rbx, %rdi
callq 0x3940
movq 0x30(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x2790
movl $0x1, -0x30(%rbp)
movq %rbx, -0x38(%rbp)
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movl $0xd, %edx
movq %r14, %rdi
leaq 0x2a03(%rip), %rsi # 0x5020
callq 0x2120
movq %r14, %rdi
movl -0x30(%rbp), %esi
callq 0x21a0
movq 0x10(%rbx), %rax
movq (%rax), %rax
movq 0x18(%rax), %rbx
movq 0x20(%rax), %r12
xorl %r15d, %r15d
cmpq %r12, %rbx
je 0x26b3
movl %r15d, %eax
movl $0xaaaaaaab, %ecx # imm = 0xAAAAAAAB
imulq %rcx, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %eax
movl (%rbx), %r13d
cmpl %r15d, %eax
jne 0x268a
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq %r14, %rdi
movl %r13d, %esi
callq 0x21a0
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
leaq -0x29(%rbp), %rsi
callq 0x2120
incl %r15d
addq $0x4, %rbx
jmp 0x263f
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20e0
movq -0x38(%rbp), %rbx
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movl $0x8, %edx
movq %r14, %rdi
leaq 0x293d(%rip), %rsi # 0x502e
callq 0x2120
movq 0x10(%rbx), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rbx
movq 0x20(%rax), %r12
cmpq %r12, %rbx
je 0x2773
movl (%rbx), %r13d
imull $0xaaaaaaab, %r15d, %eax # imm = 0xAAAAAAAB
cmpl $0x55555555, %eax # imm = 0x55555555
ja 0x274a
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq %r14, %rdi
movl %r13d, %esi
callq 0x21a0
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
leaq -0x29(%rbp), %rsi
callq 0x2120
incl %r15d
addq $0x4, %rbx
jmp 0x2709
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x3940
incl -0x30(%rbp)
movq 0x30(%rbx), %rax
cmpq 0x10(%rbx), %rax
jne 0x25e3
leaq -0x238(%rbp), %rdi
callq 0x2130
movq 0x482d(%rip), %rax # 0x6fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x230(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x238(%rbp,%rcx)
callq 0x20c0
leaq -0x140(%rbp), %rdi
callq 0x2060
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27ec
jmp 0x27ec
jmp 0x27ec
jmp 0x27ec
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
| /inani47[P]8-puzzle-BFS/app/main.cpp |
mbedtls_aes_setkey_enc | int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits )
{
unsigned int i;
uint32_t *RK;
#if !defined(MBEDTLS_AES_ROM_TABLES)
if( aes_init_done == 0 )
{
aes_gen_tables();
aes_init_done = 1;
}
#endif
switch( keybits )
{
case 128: ctx->nr = 10; break;
case 192: ctx->nr = 12; break;
case 256: ctx->nr = 14; break;
default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
}
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
if( aes_padlock_ace == -1 )
aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
if( aes_padlock_ace )
ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
else
#endif
ctx->rk = RK = ctx->buf;
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
return( mbedtls_aesni_setkey_enc( (unsigned char *) ctx->rk, key, keybits ) );
#endif
for( i = 0; i < ( keybits >> 5 ); i++ )
{
GET_UINT32_LE( RK[i], key, i << 2 );
}
switch( ctx->nr )
{
case 10:
for( i = 0; i < 10; i++, RK += 4 )
{
RK[4] = RK[0] ^ RCON[i] ^
( (uint32_t) FSb[ ( RK[3] >> 8 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( RK[3] ) & 0xFF ] << 24 );
RK[5] = RK[1] ^ RK[4];
RK[6] = RK[2] ^ RK[5];
RK[7] = RK[3] ^ RK[6];
}
break;
case 12:
for( i = 0; i < 8; i++, RK += 6 )
{
RK[6] = RK[0] ^ RCON[i] ^
( (uint32_t) FSb[ ( RK[5] >> 8 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( RK[5] ) & 0xFF ] << 24 );
RK[7] = RK[1] ^ RK[6];
RK[8] = RK[2] ^ RK[7];
RK[9] = RK[3] ^ RK[8];
RK[10] = RK[4] ^ RK[9];
RK[11] = RK[5] ^ RK[10];
}
break;
case 14:
for( i = 0; i < 7; i++, RK += 8 )
{
RK[8] = RK[0] ^ RCON[i] ^
( (uint32_t) FSb[ ( RK[7] >> 8 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( RK[7] ) & 0xFF ] << 24 );
RK[9] = RK[1] ^ RK[8];
RK[10] = RK[2] ^ RK[9];
RK[11] = RK[3] ^ RK[10];
RK[12] = RK[4] ^
( (uint32_t) FSb[ ( RK[11] ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( RK[11] >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 );
RK[13] = RK[5] ^ RK[12];
RK[14] = RK[6] ^ RK[13];
RK[15] = RK[7] ^ RK[14];
}
break;
}
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp # imm = 0x828
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x0, 0x5cbc(%rip) # 0xa120
jne 0x46ed
pushq $0x1
popq %rdx
xorl %eax, %eax
pushq $0x1b
popq %rsi
xorl %ecx, %ecx
cmpq $0x100, %rcx # imm = 0x100
je 0x44aa
movl %edx, 0x420(%rsp,%rcx,4)
movl %edx, %edi
movl %ecx, 0x20(%rsp,%rdi,4)
leal (%rdx,%rdx), %edi
cmpl $0x80, %edx
movl %esi, %r8d
cmovbl %eax, %r8d
movzbl %dil, %edi
xorl %edx, %edi
xorl %r8d, %edi
incq %rcx
movl %edi, %edx
jmp 0x4474
pushq $0x1
popq %rcx
xorl %eax, %eax
leaq 0x5c7a(%rip), %rdx # 0xa130
xorl %edi, %edi
cmpq $0x28, %rdi
je 0x44dc
movl %ecx, (%rdi,%rdx)
cmpl $0x80, %ecx
movl %esi, %r8d
cmovbl %eax, %r8d
addl %ecx, %ecx
movzbl %cl, %ecx
xorl %r8d, %ecx
addq $0x4, %rdi
jmp 0x44b8
movq %rbx, 0x18(%rsp)
movb $0x63, 0x5c78(%rip) # 0xa160
movb $0x0, 0x7dd4(%rip) # 0xc2c3
pushq $0x1
popq %rax
movl $0xff, %ecx
leaq 0x5c62(%rip), %rdi # 0xa160
leaq 0x7d5b(%rip), %r8 # 0xc260
cmpq $0x100, %rax # imm = 0x100
je 0x457d
movslq 0x20(%rsp,%rax,4), %rdx
movl $0xff, %r9d
subq %rdx, %r9
movl 0x420(%rsp,%r9,4), %r10d
leal (%r10,%r10), %edx
movl %r10d, %r9d
shrl $0x7, %r9d
orl %edx, %r9d
movl %r9d, %edx
andl %ecx, %edx
addl %r9d, %r9d
movl %edx, %r11d
shrl $0x7, %r11d
andl %ecx, %r9d
orl %r9d, %r11d
leal (%r11,%r11), %ebx
shrl $0x7, %r9d
andl %ecx, %ebx
orl %ebx, %r9d
shrl $0x7, %ebx
xorl %r10d, %edx
xorl %r11d, %edx
xorl %r9d, %edx
andl $0x7f, %r9d
leal (%rbx,%r9,2), %r9d
xorl %r9d, %edx
movslq %edx, %rdx
xorq $0x63, %rdx
movb %dl, (%rax,%rdi)
movb %al, (%rdx,%r8)
incq %rax
jmp 0x4505
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movl 0x58(%rsp), %r9d
movl 0x44(%rsp), %r10d
movl 0x4c(%rsp), %r11d
movl 0x54(%rsp), %r12d
xorl %r13d, %r13d
movl $0xff, %ebp
xorl %ebx, %ebx
cmpq $0x400, %r13 # imm = 0x400
je 0x46d7
movzbl (%rbx,%rdi), %ecx
leal (%rcx,%rcx), %edx
xorl %eax, %eax
testb %cl, %cl
movl %esi, %r15d
cmovnsl %eax, %r15d
movzbl %dl, %edx
xorl %r15d, %edx
movl %edx, %r15d
xorl %ecx, %r15d
movl %ecx, %r14d
shll $0x8, %r14d
shll $0x10, %ecx
orl %r14d, %ecx
shll $0x18, %r15d
orl %ecx, %r15d
orl %edx, %r15d
leaq 0x6c72(%rip), %rcx # 0xb260
movl %r15d, (%r13,%rcx)
movl %r15d, %ecx
roll $0x8, %ecx
leaq 0x7060(%rip), %rdx # 0xb660
movl %ecx, (%r13,%rdx)
movl %r15d, %ecx
roll $0x10, %ecx
roll $0x18, %r15d
leaq 0x744a(%rip), %rdx # 0xba60
movl %ecx, (%r13,%rdx)
leaq 0x783e(%rip), %rcx # 0xbe60
movl %r15d, (%r13,%rcx)
movzbl (%rbx,%r8), %ecx
testq %rcx, %rcx
je 0x468e
movl 0x20(%rsp,%rcx,4), %ecx
leal (%rcx,%r9), %eax
cltd
idivl %ebp
movslq %edx, %r14
leal (%rcx,%r10), %eax
cltd
idivl %ebp
movslq %edx, %rax
movl 0x420(%rsp,%rax,4), %r15d
shll $0x8, %r15d
xorl 0x420(%rsp,%r14,4), %r15d
leal (%rcx,%r12), %eax
cltd
idivl %ebp
movslq %edx, %rax
movl 0x420(%rsp,%rax,4), %r14d
shll $0x10, %r14d
addl %r11d, %ecx
movl %ecx, %eax
cltd
idivl %ebp
movslq %edx, %rax
movl 0x420(%rsp,%rax,4), %eax
shll $0x18, %eax
xorl %r14d, %eax
xorl %r15d, %eax
leaq 0x5bcb(%rip), %rcx # 0xa260
movl %eax, (%r13,%rcx)
movl %eax, %ecx
roll $0x8, %ecx
leaq 0x5fba(%rip), %rdx # 0xa660
movl %ecx, (%r13,%rdx)
movl %eax, %ecx
roll $0x10, %ecx
roll $0x18, %eax
leaq 0x63a6(%rip), %rdx # 0xaa60
movl %ecx, (%r13,%rdx)
leaq 0x679a(%rip), %rcx # 0xae60
movl %eax, (%r13,%rcx)
incq %rbx
addq $0x4, %r13
jmp 0x45a5
movb $0x1, 0x5a42(%rip) # 0xa120
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %r15
cmpl $0x80, %r14d
je 0x4714
cmpl $0x100, %r14d # imm = 0x100
je 0x4710
cmpl $0xc0, %r14d
jne 0x489a
pushq $0xc
jmp 0x4716
pushq $0xe
jmp 0x4716
pushq $0xa
popq %rax
movl %eax, (%r15)
leaq 0x10(%r15), %r12
movq %r12, 0x8(%r15)
movl $0x2000000, %edi # imm = 0x2000000
callq 0x5d88
testl %eax, %eax
je 0x4750
movq 0x8(%r15), %rdi
movl %r14d, %edx
movq %rbx, %rsi
addq $0x828, %rsp # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5fb6
shrl $0x5, %r14d
xorl %eax, %eax
cmpq %rax, %r14
je 0x4768
movl (%rbx,%rax,4), %ecx
movl %ecx, 0x10(%r15,%rax,4)
incq %rax
jmp 0x4756
movl (%r15), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
je 0x4964
cmpl $0xc, %ecx
je 0x48af
cmpl $0xe, %ecx
jne 0x489d
xorl %eax, %eax
leaq 0x599f(%rip), %rcx # 0xa130
movl $0xff, %edx
leaq 0x59c3(%rip), %rsi # 0xa160
xorl %edi, %edi
cmpq $0x1c, %rdi
je 0x489d
movl (%rdi,%rcx), %r9d
xorl (%r12,%rdi,8), %r9d
movl 0x1c(%r12,%rdi,8), %r8d
movl %r8d, %r10d
shrl $0x8, %r10d
andl %edx, %r10d
movzbl (%r10,%rsi), %r10d
xorl %r9d, %r10d
movl %r8d, %r9d
shrl $0x10, %r9d
andl %edx, %r9d
movzbl (%r9,%rsi), %r11d
shll $0x8, %r11d
xorl %r10d, %r11d
movl %r8d, %r9d
shrl $0x18, %r9d
movzbl (%r9,%rsi), %r10d
shll $0x10, %r10d
movzbl %r8b, %r9d
movzbl (%r9,%rsi), %r9d
shll $0x18, %r9d
xorl %r10d, %r9d
xorl %r11d, %r9d
movl %r9d, 0x20(%r12,%rdi,8)
xorl 0x4(%r12,%rdi,8), %r9d
movl %r9d, 0x24(%r12,%rdi,8)
xorl 0x8(%r12,%rdi,8), %r9d
movl %r9d, 0x28(%r12,%rdi,8)
xorl 0xc(%r12,%rdi,8), %r9d
movl %r9d, 0x2c(%r12,%rdi,8)
movl %r9d, %r10d
andl %edx, %r10d
movzbl (%r10,%rsi), %r10d
xorl 0x10(%r12,%rdi,8), %r10d
movl %r9d, %r11d
shrl $0x8, %r11d
andl %edx, %r11d
movzbl (%r11,%rsi), %r11d
shll $0x8, %r11d
xorl %r10d, %r11d
movl %r9d, %r10d
shrl $0x10, %r10d
andl %edx, %r10d
movzbl (%r10,%rsi), %r10d
shll $0x10, %r10d
shrl $0x18, %r9d
movzbl (%r9,%rsi), %r9d
shll $0x18, %r9d
xorl %r10d, %r9d
xorl %r11d, %r9d
movl %r9d, 0x30(%r12,%rdi,8)
xorl 0x14(%r12,%rdi,8), %r9d
movl %r9d, 0x34(%r12,%rdi,8)
xorl 0x18(%r12,%rdi,8), %r9d
movl %r9d, 0x38(%r12,%rdi,8)
xorl %r8d, %r9d
movl %r9d, 0x3c(%r12,%rdi,8)
addq $0x4, %rdi
jmp 0x479f
pushq $-0x20
popq %rax
addq $0x828, %rsp # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x587a(%rip), %rcx # 0xa130
movl $0xff, %edx
leaq 0x589e(%rip), %rsi # 0xa160
xorl %edi, %edi
cmpq $0x20, %rdi
je 0x489d
movl (%rdi,%rcx), %r9d
xorl (%r12), %r9d
movl 0x14(%r12), %r8d
movl %r8d, %r10d
shrl $0x8, %r10d
andl %edx, %r10d
movzbl (%r10,%rsi), %r10d
xorl %r9d, %r10d
movl %r8d, %r9d
shrl $0x10, %r9d
andl %edx, %r9d
movzbl (%r9,%rsi), %r9d
shll $0x8, %r9d
xorl %r10d, %r9d
movl %r8d, %r10d
shrl $0x18, %r10d
movzbl (%r10,%rsi), %r10d
shll $0x10, %r10d
movzbl %r8b, %r11d
movzbl (%r11,%rsi), %r11d
shll $0x18, %r11d
xorl %r10d, %r11d
xorl %r9d, %r11d
movl %r11d, 0x18(%r12)
xorl 0x4(%r12), %r11d
movl %r11d, 0x1c(%r12)
xorl 0x8(%r12), %r11d
movl %r11d, 0x20(%r12)
xorl 0xc(%r12), %r11d
movl %r11d, 0x24(%r12)
xorl 0x10(%r12), %r11d
movl %r11d, 0x28(%r12)
xorl %r8d, %r11d
movl %r11d, 0x2c(%r12)
addq $0x18, %r12
addq $0x4, %rdi
jmp 0x48c4
leaq 0x57c5(%rip), %rcx # 0xa130
movl $0xff, %edx
leaq 0x57e9(%rip), %rsi # 0xa160
xorl %edi, %edi
cmpq $0x28, %rdi
je 0x489d
movl (%rdi,%rcx), %r9d
xorl (%r12,%rdi,4), %r9d
movl 0xc(%r12,%rdi,4), %r8d
movl %r8d, %r10d
shrl $0x8, %r10d
andl %edx, %r10d
movzbl (%r10,%rsi), %r10d
xorl %r9d, %r10d
movl %r8d, %r9d
shrl $0x10, %r9d
andl %edx, %r9d
movzbl (%r9,%rsi), %r9d
shll $0x8, %r9d
xorl %r10d, %r9d
movl %r8d, %r10d
shrl $0x18, %r10d
movzbl (%r10,%rsi), %r10d
shll $0x10, %r10d
movzbl %r8b, %r11d
movzbl (%r11,%rsi), %r11d
shll $0x18, %r11d
xorl %r10d, %r11d
xorl %r9d, %r11d
movl %r11d, 0x10(%r12,%rdi,4)
xorl 0x4(%r12,%rdi,4), %r11d
movl %r11d, 0x14(%r12,%rdi,4)
xorl 0x8(%r12,%rdi,4), %r11d
movl %r11d, 0x18(%r12,%rdi,4)
xorl %r8d, %r11d
movl %r11d, 0x1c(%r12,%rdi,4)
addq $0x4, %rdi
jmp 0x4979
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_aes_setkey_dec | int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits )
{
int i, j, ret;
mbedtls_aes_context cty;
uint32_t *RK;
uint32_t *SK;
mbedtls_aes_init( &cty );
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
if( aes_padlock_ace == -1 )
aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
if( aes_padlock_ace )
ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
else
#endif
ctx->rk = RK = ctx->buf;
/* Also checks keybits */
if( ( ret = mbedtls_aes_setkey_enc( &cty, key, keybits ) ) != 0 )
goto exit;
ctx->nr = cty.nr;
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
{
mbedtls_aesni_inverse_key( (unsigned char *) ctx->rk,
(const unsigned char *) cty.rk, ctx->nr );
goto exit;
}
#endif
SK = cty.rk + cty.nr * 4;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
{
for( j = 0; j < 4; j++, SK++ )
{
*RK++ = AES_RT0( FSb[ ( *SK ) & 0xFF ] ) ^
AES_RT1( FSb[ ( *SK >> 8 ) & 0xFF ] ) ^
AES_RT2( FSb[ ( *SK >> 16 ) & 0xFF ] ) ^
AES_RT3( FSb[ ( *SK >> 24 ) & 0xFF ] );
}
}
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
exit:
mbedtls_aes_free( &cty );
return( ret );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movl $0x120, %edx # imm = 0x120
movq %r12, %rdi
xorl %esi, %esi
callq 0x20c0
leaq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x4443
movl %eax, %ebx
testl %eax, %eax
jne 0x4b64
movl 0x8(%rsp), %eax
movl %eax, (%r14)
movl $0x2000000, %edi # imm = 0x2000000
callq 0x5d88
testl %eax, %eax
je 0x4a7c
movq 0x8(%r14), %rdi
movq 0x10(%rsp), %rsi
movl (%r14), %edx
callq 0x5f7b
jmp 0x4b64
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
movl 0x10(%rax), %ecx
movl %ecx, 0x10(%r14)
movl 0x14(%rax), %ecx
movl %ecx, 0x14(%r14)
movl 0x18(%rax), %ecx
movl %ecx, 0x18(%r14)
movl 0x1c(%rax), %edx
leaq 0x20(%r14), %rcx
movl %edx, 0x1c(%r14)
movl (%r14), %edx
leaq 0x56a5(%rip), %rsi # 0xa160
leaq 0x579e(%rip), %rdi # 0xa260
movl $0xff, %r8d
leaq 0x5b91(%rip), %r9 # 0xa660
leaq 0x5f8a(%rip), %r10 # 0xaa60
leaq 0x6383(%rip), %r11 # 0xae60
cmpl $0x2, %edx
jl 0x4b4e
decl %edx
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpl $0x4, %r15d
je 0x4b42
movl (%rax,%r15,4), %r12d
movzbl %r12b, %r13d
movzbl (%r13,%rsi), %r13d
movl %r12d, %ebp
shrl $0x8, %ebp
andl %r8d, %ebp
movzbl (%rbp,%rsi), %ebp
movl (%r9,%rbp,4), %ebp
xorl (%rdi,%r13,4), %ebp
movl %r12d, %r13d
shrl $0x10, %r13d
andl %r8d, %r13d
movzbl (%r13,%rsi), %r13d
xorl (%r10,%r13,4), %ebp
shrl $0x18, %r12d
movzbl (%r12,%rsi), %r12d
xorl (%r11,%r12,4), %ebp
movl %ebp, (%rcx,%r15,4)
incq %r15
addq $-0x4, %r14
jmp 0x4aea
subq %r14, %rcx
subq %r14, %rax
addq $-0x20, %rax
jmp 0x4add
movl (%rax), %edx
movl %edx, (%rcx)
movl 0x4(%rax), %edx
movl %edx, 0x4(%rcx)
movl 0x8(%rax), %edx
movl %edx, 0x8(%rcx)
movl 0xc(%rax), %eax
movl %eax, 0xc(%rcx)
leaq 0x8(%rsp), %rdi
callq 0x4424
movl %ebx, %eax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_internal_aes_encrypt | int mbedtls_internal_aes_encrypt( mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16] )
{
int i;
uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
RK = ctx->rk;
GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
GET_UINT32_LE( X1, input, 4 ); X1 ^= *RK++;
GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++;
GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
{
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
}
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
X0 = *RK++ ^ \
( (uint32_t) FSb[ ( Y0 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
X1 = *RK++ ^ \
( (uint32_t) FSb[ ( Y1 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
X2 = *RK++ ^ \
( (uint32_t) FSb[ ( Y2 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
X3 = *RK++ ^ \
( (uint32_t) FSb[ ( Y3 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
PUT_UINT32_LE( X0, output, 0 );
PUT_UINT32_LE( X1, output, 4 );
PUT_UINT32_LE( X2, output, 8 );
PUT_UINT32_LE( X3, output, 12 );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
movl (%rax), %r8d
movl 0x4(%rax), %r9d
xorl (%rsi), %r8d
xorl 0x4(%rsi), %r9d
movq %rdx, -0x8(%rsp)
movl 0x8(%rax), %r11d
xorl 0x8(%rsi), %r11d
movl 0xc(%rax), %edx
xorl 0xc(%rsi), %edx
movl (%rdi), %ecx
sarl %ecx
addq $0x2c, %rax
movl $0xff, %ebp
leaq 0x669b(%rip), %r10 # 0xb260
movl $0x3fc, %r14d # imm = 0x3FC
leaq 0x6a8e(%rip), %rbx # 0xb660
leaq 0x6e87(%rip), %rdi # 0xba60
leaq 0x7280(%rip), %rsi # 0xbe60
cmpl $0x2, %ecx
jl 0x4d68
movl %ecx, -0x14(%rsp)
movl %r8d, %ecx
andl %ebp, %ecx
movl (%r10,%rcx,4), %r12d
xorl -0x1c(%rax), %r12d
movl %r9d, %ecx
shrl $0x8, %ecx
andl %ebp, %ecx
xorl (%rbx,%rcx,4), %r12d
movl %r11d, %ecx
shrl $0xe, %ecx
andl %r14d, %ecx
xorl (%rcx,%rdi), %r12d
movl %edx, %ecx
shrl $0x18, %ecx
xorl (%rsi,%rcx,4), %r12d
movl %r9d, %ecx
andl %ebp, %ecx
movl (%r10,%rcx,4), %r13d
xorl -0x18(%rax), %r13d
movl %r11d, %ecx
shrl $0x8, %ecx
andl %ebp, %ecx
xorl (%rbx,%rcx,4), %r13d
movl %edx, %ecx
shrl $0xe, %ecx
andl %r14d, %ecx
xorl (%rcx,%rdi), %r13d
movl %r8d, %ecx
shrl $0x18, %ecx
xorl (%rsi,%rcx,4), %r13d
movl %r11d, %ecx
andl %ebp, %ecx
movl (%r10,%rcx,4), %ecx
xorl -0x14(%rax), %ecx
movl %edx, %r15d
shrl $0x8, %r15d
andl %ebp, %r15d
xorl (%rbx,%r15,4), %ecx
movl %r8d, %r15d
shrl $0xe, %r15d
andl %r14d, %r15d
xorl (%r15,%rdi), %ecx
movl %r9d, %r15d
shrl $0x18, %r15d
xorl (%rsi,%r15,4), %ecx
andl %ebp, %edx
movl (%r10,%rdx,4), %r15d
xorl -0x10(%rax), %r15d
shrl $0x8, %r8d
andl %ebp, %r8d
xorl (%rbx,%r8,4), %r15d
shrl $0xe, %r9d
andl %r14d, %r9d
xorl (%r9,%rdi), %r15d
shrl $0x18, %r11d
xorl (%rsi,%r11,4), %r15d
movl %r12d, %edx
andl %ebp, %edx
movl (%r10,%rdx,4), %r8d
xorl -0xc(%rax), %r8d
movl %r13d, %edx
shrl $0x8, %edx
andl %ebp, %edx
xorl (%rbx,%rdx,4), %r8d
movl %ecx, %edx
shrl $0xe, %edx
andl %r14d, %edx
xorl (%rdx,%rdi), %r8d
movl %r15d, %edx
shrl $0x18, %edx
xorl (%rsi,%rdx,4), %r8d
movl %r13d, %edx
andl %ebp, %edx
movl (%r10,%rdx,4), %r9d
xorl -0x8(%rax), %r9d
movl %ecx, %edx
shrl $0x8, %edx
andl %ebp, %edx
xorl (%rbx,%rdx,4), %r9d
movl %r15d, %edx
shrl $0xe, %edx
andl %r14d, %edx
xorl (%rdx,%rdi), %r9d
movl %r12d, %edx
shrl $0x18, %edx
xorl (%rsi,%rdx,4), %r9d
movl %ecx, %edx
andl %ebp, %edx
movl (%r10,%rdx,4), %r11d
xorl -0x4(%rax), %r11d
movl %r15d, %edx
shrl $0x8, %edx
andl %ebp, %edx
xorl (%rbx,%rdx,4), %r11d
movl %r12d, %edx
shrl $0xe, %edx
andl %r14d, %edx
xorl (%rdx,%rdi), %r11d
movl %r13d, %edx
shrl $0x18, %edx
xorl (%rsi,%rdx,4), %r11d
andl %ebp, %r15d
movl (%r10,%r15,4), %edx
xorl (%rax), %edx
shrl $0x8, %r12d
andl %ebp, %r12d
xorl (%rbx,%r12,4), %edx
shrl $0xe, %r13d
andl %r14d, %r13d
xorl (%r13,%rdi), %edx
shrl $0x18, %ecx
xorl (%rsi,%rcx,4), %edx
movl -0x14(%rsp), %ecx
decl %ecx
addq $0x20, %rax
jmp 0x4be0
movl $0xff, %esi
movl %r8d, %ecx
andl %esi, %ecx
movl (%r10,%rcx,4), %ebp
xorl -0x1c(%rax), %ebp
movl %r9d, %ecx
shrl $0x8, %ecx
andl %esi, %ecx
leaq 0x68d8(%rip), %rbx # 0xb660
xorl (%rbx,%rcx,4), %ebp
movl %r11d, %r14d
shrl $0xe, %r14d
movl $0x3fc, %ecx # imm = 0x3FC
andl %ecx, %r14d
leaq 0x6cbf(%rip), %rdi # 0xba60
xorl (%r14,%rdi), %ebp
movl %edx, %r14d
shrl $0x18, %r14d
leaq 0x70ad(%rip), %rsi # 0xbe60
xorl (%rsi,%r14,4), %ebp
movl %r9d, %r14d
movl $0xff, %r13d
andl %r13d, %r14d
movl (%r10,%r14,4), %r12d
xorl -0x18(%rax), %r12d
movl %r11d, %r15d
shrl $0x8, %r15d
andl %r13d, %r15d
movl $0xff, %r14d
xorl (%rbx,%r15,4), %r12d
movl %edx, %r15d
shrl $0xe, %r15d
andl %ecx, %r15d
xorl (%r15,%rdi), %r12d
movl %r8d, %r15d
shrl $0x18, %r15d
xorl (%rsi,%r15,4), %r12d
movl %r11d, %r15d
andl %r14d, %r15d
movl (%r10,%r15,4), %r13d
xorl -0x14(%rax), %r13d
movl %edx, %r15d
shrl $0x8, %r15d
andl %r14d, %r15d
xorl (%rbx,%r15,4), %r13d
movq %rbx, %r14
movl %r8d, %r15d
shrl $0xe, %r15d
andl %ecx, %r15d
xorl (%r15,%rdi), %r13d
movl %r9d, %r15d
shrl $0x18, %r15d
xorl (%rsi,%r15,4), %r13d
movl $0xff, %ebx
andl %ebx, %edx
movl (%r10,%rdx,4), %r10d
xorl -0x10(%rax), %r10d
shrl $0x8, %r8d
andl %ebx, %r8d
xorl (%r14,%r8,4), %r10d
shrl $0xe, %r9d
andl %ecx, %r9d
xorl (%r9,%rdi), %r10d
shrl $0x18, %r11d
xorl (%rsi,%r11,4), %r10d
movl %ebp, %ecx
andl %ebx, %ecx
leaq 0x52f8(%rip), %r8 # 0xa160
movzbl (%rcx,%r8), %edi
xorl -0xc(%rax), %edi
movl %r12d, %ecx
shrl $0x8, %ecx
andl %ebx, %ecx
movzbl (%rcx,%r8), %ecx
shll $0x8, %ecx
movl %r13d, %edx
shrl $0x10, %edx
andl %ebx, %edx
movzbl (%rdx,%r8), %edx
shll $0x10, %edx
orl %ecx, %edx
movl %r10d, %ecx
shrl $0x18, %ecx
movzbl (%rcx,%r8), %ecx
shll $0x18, %ecx
movl %r12d, %esi
andl %ebx, %esi
movzbl (%rsi,%r8), %esi
xorl -0x8(%rax), %esi
movl %esi, -0x14(%rsp)
orl %edx, %ecx
movl %r13d, %r11d
shrl $0x8, %r11d
andl %ebx, %r11d
movl %r10d, %r15d
shrl $0x10, %r15d
andl %ebx, %r15d
movl %r13d, %edx
andl %ebx, %edx
movzbl (%rdx,%r8), %edx
xorl -0x4(%rax), %edx
movl %edx, -0xc(%rsp)
movl %r10d, %edx
shrl $0x8, %edx
andl %ebx, %edx
andl %ebx, %r10d
movzbl (%r10,%r8), %esi
xorl (%rax), %esi
movl %esi, -0x10(%rsp)
movq %rbp, %r9
movl %ebp, %r10d
shrl $0x10, %r10d
andl %ebx, %r10d
movl %ebp, %eax
shrl $0x8, %r9d
andl %ebx, %r9d
movl %r12d, %r14d
shrl $0x10, %r12d
andl %ebx, %r12d
xorl %edi, %ecx
movzbl (%r11,%r8), %esi
movzbl (%r15,%r8), %r11d
shrl $0x18, %eax
movzbl (%rax,%r8), %eax
movzbl (%rdx,%r8), %r15d
movzbl (%r10,%r8), %ebp
shrl $0x18, %r14d
movzbl (%r14,%r8), %ebx
movzbl (%r9,%r8), %r10d
movzbl (%r12,%r8), %r14d
shrl $0x18, %r13d
movzbl (%r13,%r8), %r8d
movq -0x8(%rsp), %rdx
movb %dil, (%rdx)
movb %ch, 0x1(%rdx)
movl %ecx, %edi
shrl $0x10, %edi
movb %dil, 0x2(%rdx)
shrl $0x18, %ecx
movb %cl, 0x3(%rdx)
shll $0x8, %esi
shll $0x10, %r11d
orl %esi, %r11d
shll $0x18, %eax
orl %r11d, %eax
movl -0x14(%rsp), %ecx
xorl %ecx, %eax
movb %cl, 0x4(%rdx)
movb %ah, 0x5(%rdx)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x6(%rdx)
shrl $0x18, %eax
movb %al, 0x7(%rdx)
shll $0x8, %r15d
shll $0x10, %ebp
orl %r15d, %ebp
shll $0x18, %ebx
orl %ebp, %ebx
movl -0xc(%rsp), %eax
xorl %eax, %ebx
movb %al, 0x8(%rdx)
movb %bh, 0x9(%rdx)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0xa(%rdx)
shrl $0x18, %ebx
movb %bl, 0xb(%rdx)
shll $0x8, %r10d
shll $0x10, %r14d
orl %r10d, %r14d
movl %r8d, %ecx
shll $0x18, %ecx
orl %r14d, %ecx
movl -0x10(%rsp), %eax
xorl %eax, %ecx
movb %al, 0xc(%rdx)
movb %ch, 0xd(%rdx)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0xe(%rdx)
shrl $0x18, %ecx
movb %cl, 0xf(%rdx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_internal_aes_decrypt | int mbedtls_internal_aes_decrypt( mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16] )
{
int i;
uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
RK = ctx->rk;
GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
GET_UINT32_LE( X1, input, 4 ); X1 ^= *RK++;
GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++;
GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
{
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
}
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
X0 = *RK++ ^ \
( (uint32_t) RSb[ ( Y0 ) & 0xFF ] ) ^
( (uint32_t) RSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
X1 = *RK++ ^ \
( (uint32_t) RSb[ ( Y1 ) & 0xFF ] ) ^
( (uint32_t) RSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
X2 = *RK++ ^ \
( (uint32_t) RSb[ ( Y2 ) & 0xFF ] ) ^
( (uint32_t) RSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
X3 = *RK++ ^ \
( (uint32_t) RSb[ ( Y3 ) & 0xFF ] ) ^
( (uint32_t) RSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
PUT_UINT32_LE( X0, output, 0 );
PUT_UINT32_LE( X1, output, 4 );
PUT_UINT32_LE( X2, output, 8 );
PUT_UINT32_LE( X3, output, 12 );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
movl (%rax), %ecx
movl 0x4(%rax), %r8d
xorl (%rsi), %ecx
xorl 0x4(%rsi), %r8d
movq %rdx, -0x8(%rsp)
movl 0x8(%rax), %r11d
xorl 0x8(%rsi), %r11d
movl 0xc(%rax), %r15d
xorl 0xc(%rsi), %r15d
movl (%rdi), %edx
sarl %edx
addq $0x2c, %rax
movl $0xff, %ebp
leaq 0x5227(%rip), %r10 # 0xa260
movl $0x3fc, %r14d # imm = 0x3FC
leaq 0x561a(%rip), %rbx # 0xa660
leaq 0x5e13(%rip), %rdi # 0xae60
cmpl $0x2, %edx
jl 0x51ed
movl %ecx, %esi
andl %ebp, %esi
movl (%r10,%rsi,4), %r12d
xorl -0x1c(%rax), %r12d
movl %r15d, %esi
shrl $0x8, %esi
andl %ebp, %esi
xorl (%rbx,%rsi,4), %r12d
movl %r11d, %esi
shrl $0xe, %esi
andl %r14d, %esi
movl %edx, -0x18(%rsp)
leaq 0x59de(%rip), %rdx # 0xaa60
xorl (%rsi,%rdx), %r12d
movl %r8d, %esi
shrl $0x18, %esi
xorl (%rdi,%rsi,4), %r12d
movl %r8d, %esi
andl %ebp, %esi
movl (%r10,%rsi,4), %r13d
xorl -0x18(%rax), %r13d
movl %ecx, %esi
shrl $0x8, %esi
andl %ebp, %esi
xorl (%rbx,%rsi,4), %r13d
movl %r15d, %esi
shrl $0xe, %esi
andl %r14d, %esi
xorl (%rsi,%rdx), %r13d
movl %r11d, %esi
shrl $0x18, %esi
xorl (%rdi,%rsi,4), %r13d
movl %r11d, %esi
andl %ebp, %esi
movl (%r10,%rsi,4), %esi
xorl -0x14(%rax), %esi
movl %r8d, %r9d
shrl $0x8, %r9d
andl %ebp, %r9d
xorl (%rbx,%r9,4), %esi
movl %ecx, %r9d
shrl $0xe, %r9d
andl %r14d, %r9d
xorl (%r9,%rdx), %esi
movl %r15d, %r9d
shrl $0x18, %r9d
xorl (%rdi,%r9,4), %esi
andl %ebp, %r15d
movl (%r10,%r15,4), %r15d
xorl -0x10(%rax), %r15d
shrl $0x8, %r11d
andl %ebp, %r11d
xorl (%rbx,%r11,4), %r15d
shrl $0xe, %r8d
andl %r14d, %r8d
xorl (%r8,%rdx), %r15d
shrl $0x18, %ecx
xorl (%rdi,%rcx,4), %r15d
movl %r12d, %ecx
andl %ebp, %ecx
movl (%r10,%rcx,4), %ecx
xorl -0xc(%rax), %ecx
movl %r15d, %r8d
shrl $0x8, %r8d
andl %ebp, %r8d
xorl (%rbx,%r8,4), %ecx
movl %esi, %r8d
shrl $0xe, %r8d
andl %r14d, %r8d
xorl (%r8,%rdx), %ecx
movl %r13d, %r8d
shrl $0x18, %r8d
xorl (%rdi,%r8,4), %ecx
movl %r13d, %r8d
andl %ebp, %r8d
movl (%r10,%r8,4), %r8d
xorl -0x8(%rax), %r8d
movl %r12d, %r9d
shrl $0x8, %r9d
andl %ebp, %r9d
xorl (%rbx,%r9,4), %r8d
movl %r15d, %r9d
shrl $0xe, %r9d
andl %r14d, %r9d
xorl (%r9,%rdx), %r8d
movl %esi, %r9d
shrl $0x18, %r9d
xorl (%rdi,%r9,4), %r8d
movl %esi, %r9d
andl %ebp, %r9d
movl (%r10,%r9,4), %r11d
xorl -0x4(%rax), %r11d
movl %r13d, %r9d
shrl $0x8, %r9d
andl %ebp, %r9d
xorl (%rbx,%r9,4), %r11d
movl %r12d, %r9d
shrl $0xe, %r9d
andl %r14d, %r9d
xorl (%r9,%rdx), %r11d
movl %r15d, %r9d
shrl $0x18, %r9d
xorl (%rdi,%r9,4), %r11d
andl %ebp, %r15d
movl (%r10,%r15,4), %r15d
xorl (%rax), %r15d
shrl $0x8, %esi
andl %ebp, %esi
xorl (%rbx,%rsi,4), %r15d
shrl $0xe, %r13d
andl %r14d, %r13d
xorl (%r13,%rdx), %r15d
movl -0x18(%rsp), %edx
shrl $0x18, %r12d
xorl (%rdi,%r12,4), %r15d
decl %edx
addq $0x20, %rax
jmp 0x504d
movl $0xff, %ebp
movl %ecx, %esi
andl %ebp, %esi
movl (%r10,%rsi,4), %ebx
xorl -0x1c(%rax), %ebx
movl %r15d, %esi
shrl $0x8, %esi
andl %ebp, %esi
leaq 0x5454(%rip), %r14 # 0xa660
xorl (%r14,%rsi,4), %ebx
movl %r11d, %r9d
shrl $0xe, %r9d
movl $0x3fc, %esi # imm = 0x3FC
andl %esi, %r9d
leaq 0x583a(%rip), %rdx # 0xaa60
xorl (%r9,%rdx), %ebx
movl %r8d, %r9d
shrl $0x18, %r9d
leaq 0x5c28(%rip), %rdi # 0xae60
xorl (%rdi,%r9,4), %ebx
movq %rbx, %r13
movl %r8d, %r9d
andl %ebp, %r9d
movl (%r10,%r9,4), %ebx
xorl -0x18(%rax), %ebx
movl %ecx, %r9d
shrl $0x8, %r9d
andl %ebp, %r9d
xorl (%r14,%r9,4), %ebx
movl %r15d, %r9d
shrl $0xe, %r9d
andl %esi, %r9d
xorl (%r9,%rdx), %ebx
movl %r11d, %r9d
shrl $0x18, %r9d
xorl (%rdi,%r9,4), %ebx
movl %r11d, %r9d
andl %ebp, %r9d
movl (%r10,%r9,4), %r12d
xorl -0x14(%rax), %r12d
movl %r8d, %r9d
shrl $0x8, %r9d
andl %ebp, %r9d
xorl (%r14,%r9,4), %r12d
movl %ecx, %r9d
shrl $0xe, %r9d
andl %esi, %r9d
xorl (%r9,%rdx), %r12d
movl %r15d, %r9d
shrl $0x18, %r9d
xorl (%rdi,%r9,4), %r12d
andl %ebp, %r15d
movl (%r10,%r15,4), %r10d
xorl -0x10(%rax), %r10d
shrl $0x8, %r11d
andl %ebp, %r11d
xorl (%r14,%r11,4), %r10d
shrl $0xe, %r8d
andl %esi, %r8d
xorl (%r8,%rdx), %r10d
shrl $0x18, %ecx
xorl (%rdi,%rcx,4), %r10d
movl %r13d, %ecx
andl %ebp, %ecx
leaq 0x6f84(%rip), %r8 # 0xc260
movzbl (%rcx,%r8), %edi
xorl -0xc(%rax), %edi
movl %r10d, %ecx
shrl $0x8, %ecx
andl %ebp, %ecx
movzbl (%rcx,%r8), %ecx
shll $0x8, %ecx
movl %r12d, %edx
shrl $0x10, %edx
andl %ebp, %edx
movzbl (%rdx,%r8), %edx
shll $0x10, %edx
orl %ecx, %edx
movl %ebx, %ecx
shrl $0x18, %ecx
movzbl (%rcx,%r8), %ecx
shll $0x18, %ecx
movl %ebx, %esi
andl %ebp, %esi
movzbl (%rsi,%r8), %esi
xorl -0x8(%rax), %esi
movl %esi, -0x18(%rsp)
orl %edx, %ecx
movl %r13d, %r11d
movq %r13, -0x10(%rsp)
shrl $0x8, %r11d
andl %ebp, %r11d
movl %r10d, %r15d
shrl $0x10, %r15d
movl %r12d, %edx
andl %ebp, %edx
movzbl (%rdx,%r8), %edx
xorl -0x4(%rax), %edx
movl %edx, -0x14(%rsp)
movl %r10d, %edx
andl %ebp, %r10d
movzbl (%r10,%r8), %r9d
xorl (%rax), %r9d
andl %ebp, %r15d
movl %ebx, %r14d
shrl $0x8, %r14d
andl %ebp, %r14d
shrl $0x10, %r13d
andl %ebp, %r13d
movl %r12d, %eax
shrl $0x8, %r12d
andl %ebp, %r12d
shrl $0x10, %ebx
andl %ebp, %ebx
xorl %edi, %ecx
movzbl (%r11,%r8), %esi
movzbl (%r15,%r8), %r10d
shrl $0x18, %eax
movzbl (%rax,%r8), %eax
movzbl (%r14,%r8), %r15d
movzbl (%r13,%r8), %r14d
shrl $0x18, %edx
movzbl (%rdx,%r8), %edx
movzbl (%r12,%r8), %r12d
movzbl (%rbx,%r8), %r11d
movq -0x10(%rsp), %rbx
shrl $0x18, %ebx
movzbl (%rbx,%r8), %ebx
movq -0x8(%rsp), %rbp
movb %dil, (%rbp)
movb %ch, 0x1(%rbp)
movl %ecx, %edi
shrl $0x10, %edi
movb %dil, 0x2(%rbp)
shrl $0x18, %ecx
movb %cl, 0x3(%rbp)
shll $0x8, %esi
shll $0x10, %r10d
orl %esi, %r10d
shll $0x18, %eax
orl %r10d, %eax
movl -0x18(%rsp), %ecx
xorl %ecx, %eax
movb %cl, 0x4(%rbp)
movb %ah, 0x5(%rbp)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x6(%rbp)
shrl $0x18, %eax
movb %al, 0x7(%rbp)
shll $0x8, %r15d
shll $0x10, %r14d
orl %r15d, %r14d
shll $0x18, %edx
orl %r14d, %edx
movl -0x14(%rsp), %eax
xorl %eax, %edx
movb %al, 0x8(%rbp)
movb %dh, 0x9(%rbp)
movl %edx, %eax
shrl $0x10, %eax
movb %al, 0xa(%rbp)
shrl $0x18, %edx
movb %dl, 0xb(%rbp)
shll $0x8, %r12d
shll $0x10, %r11d
orl %r12d, %r11d
shll $0x18, %ebx
orl %r11d, %ebx
xorl %r9d, %ebx
movb %r9b, 0xc(%rbp)
movb %bh, 0xd(%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0xe(%rbp)
shrl $0x18, %ebx
movb %bl, 0xf(%rbp)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_aes_crypt_ecb | int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
return( mbedtls_aesni_crypt_ecb( ctx, mode, input, output ) );
#endif
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
if( aes_padlock_ace )
{
if( mbedtls_padlock_xcryptecb( ctx, mode, input, output ) == 0 )
return( 0 );
// If padlock data misaligned, we just fall back to
// unaccelerated mode
//
}
#endif
if( mode == MBEDTLS_AES_ENCRYPT )
return( mbedtls_internal_aes_encrypt( ctx, input, output ) );
else
return( mbedtls_internal_aes_decrypt( ctx, input, output ) );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x2000000, %edi # imm = 0x2000000
callq 0x5d88
movq %r15, %rdi
testl %eax, %eax
je 0x54a0
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5db7
movq %r14, %rsi
movq %rbx, %rdx
cmpl $0x1, %ebp
jne 0x54b2
callq 0x4b82
jmp 0x54b7
callq 0x4ff6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_aes_crypt_cbc | int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[16];
if( length % 16 )
return( MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
if( aes_padlock_ace )
{
if( mbedtls_padlock_xcryptcbc( ctx, mode, length, iv, input, output ) == 0 )
return( 0 );
// If padlock data misaligned, we just fall back to
// unaccelerated mode
//
}
#endif
if( mode == MBEDTLS_AES_DECRYPT )
{
while( length > 0 )
{
memcpy( temp, input, 16 );
mbedtls_aes_crypt_ecb( ctx, mode, input, output );
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
memcpy( iv, temp, 16 );
input += 16;
output += 16;
length -= 16;
}
}
else
{
while( length > 0 )
{
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
mbedtls_aes_crypt_ecb( ctx, mode, output, output );
memcpy( iv, output, 16 );
input += 16;
output += 16;
length -= 16;
}
}
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
testb $0xf, %r12b
je 0x54e1
pushq $-0x22
popq %r13
jmp 0x553a
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %esi, %r13d
movq %rdi, %rbp
testl %esi, %esi
je 0x554c
testq %r12, %r12
je 0x5537
xorl %eax, %eax
cmpq $0x10, %rax
je 0x5511
movb (%r15,%rax), %cl
xorb (%r14,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x54fb
movq %rbp, %rdi
movl %r13d, %esi
movq %rbx, %rdx
movq %rbx, %rcx
callq 0x5466
movups (%rbx), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addq $-0x10, %r12
jmp 0x54f4
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
testq %r12, %r12
je 0x553a
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq %rbp, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x5466
xorl %eax, %eax
cmpq $0x10, %rax
je 0x5580
movb (%r15,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
jmp 0x556e
movaps (%rsp), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addq $-0x10, %r12
jmp 0x554f
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_aes_crypt_cfb128 | int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
int mode,
size_t length,
size_t *iv_off,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
int c;
size_t n = *iv_off;
if( mode == MBEDTLS_AES_DECRYPT )
{
while( length-- )
{
if( n == 0 )
mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
c = *input++;
*output++ = (unsigned char)( c ^ iv[n] );
iv[n] = (unsigned char) c;
n = ( n + 1 ) & 0x0F;
}
}
else
{
while( length-- )
{
if( n == 0 )
mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
n = ( n + 1 ) & 0x0F;
}
}
*iv_off = n;
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rdx, %r12
movq %rdi, 0x8(%rsp)
movq 0x50(%rsp), %rbp
movq %rcx, 0x10(%rsp)
movq (%rcx), %rbx
xorl %r13d, %r13d
testl %esi, %esi
je 0x5631
cmpq %r13, %r12
je 0x5636
testq %rbx, %rbx
jne 0x55e3
movq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %r15, %rcx
callq 0x5466
movb (%r14,%r13), %al
xorb (%r15,%rbx), %al
movb %al, (%rbp,%r13)
movb %al, (%r15,%rbx)
incl %ebx
andl $0xf, %ebx
incq %r13
jmp 0x55c6
testq %rbx, %rbx
jne 0x5616
movq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %r15, %rcx
callq 0x5466
movb (%r14,%r13), %al
movb (%r15,%rbx), %cl
xorb %al, %cl
movb %cl, (%rbp,%r13)
movb %al, (%r15,%rbx)
incl %ebx
andl $0xf, %ebx
incq %r13
cmpq %r13, %r12
jne 0x55fe
movq 0x10(%rsp), %rax
movq %rbx, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_aes_crypt_cfb8 | int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
unsigned char c;
unsigned char ov[17];
while( length-- )
{
memcpy( ov, iv, 16 );
mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
if( mode == MBEDTLS_AES_DECRYPT )
ov[16] = *input;
c = *output++ = (unsigned char)( iv[0] ^ *input++ );
if( mode == MBEDTLS_AES_ENCRYPT )
ov[16] = c;
memcpy( iv, ov + 1, 16 );
}
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x8(%rsp)
movq %r8, (%rsp)
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x56d7
movups (%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r13, %rdi
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %r15, %rcx
callq 0x5466
testl %ebp, %ebp
movq (%rsp), %rax
movzbl (%rax,%r14), %eax
movzbl %bl, %ecx
cmovel %eax, %ecx
movb (%r15), %dl
xorb %al, %dl
cmpl $0x1, %ebp
movq 0x8(%rsp), %rax
movb %dl, (%rax,%r14)
movzbl %dl, %ebx
cmovnel %ecx, %ebx
leaq 0x11(%rsp), %rcx
movq (%rcx), %rax
movq 0x7(%rcx), %rcx
movq %rcx, 0x7(%r15)
movq %rax, (%r15)
movb %bl, 0xf(%r15)
incq %r14
jmp 0x5674
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_aes_crypt_ctr | int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,
size_t length,
size_t *nc_off,
unsigned char nonce_counter[16],
unsigned char stream_block[16],
const unsigned char *input,
unsigned char *output )
{
int c, i;
size_t n = *nc_off;
while( length-- )
{
if( n == 0 ) {
mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, nonce_counter, stream_block );
for( i = 16; i > 0; i-- )
if( ++nonce_counter[i - 1] != 0 )
break;
}
c = *input++;
*output++ = (unsigned char)( c ^ stream_block[n] );
n = ( n + 1 ) & 0x0F;
}
*nc_off = n;
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, 0x10(%rsp)
movq 0x50(%rsp), %rbp
movq %rdx, 0x8(%rsp)
movq (%rdx), %r15
subq $0x1, %r13
jb 0x575f
testq %r15, %r15
jne 0x5747
movq 0x10(%rsp), %rdi
pushq $0x1
popq %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x5466
pushq $0x10
popq %rcx
movl %ecx, %eax
subl $0x1, %eax
jb 0x5747
movl %ecx, %ecx
incb -0x1(%r12,%rcx)
movl %eax, %ecx
je 0x5737
movb (%r14,%r15), %al
xorb (%rbx), %al
incq %rbx
movb %al, (%rbp)
incq %rbp
incl %r15d
andl $0xf, %r15d
jmp 0x5714
movq 0x8(%rsp), %rax
movq %r15, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_aes_self_test | int mbedtls_aes_self_test( int verbose )
{
int ret = 0, i, j, u, mode;
unsigned int keybits;
unsigned char key[32];
unsigned char buf[64];
const unsigned char *aes_tests;
#if defined(MBEDTLS_CIPHER_MODE_CBC) || defined(MBEDTLS_CIPHER_MODE_CFB)
unsigned char iv[16];
#endif
#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char prv[16];
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR) || defined(MBEDTLS_CIPHER_MODE_CFB)
size_t offset;
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
int len;
unsigned char nonce_counter[16];
unsigned char stream_block[16];
#endif
mbedtls_aes_context ctx;
memset( key, 0, 32 );
mbedtls_aes_init( &ctx );
/*
* ECB mode
*/
for( i = 0; i < 6; i++ )
{
u = i >> 1;
keybits = 128 + u * 64;
mode = i & 1;
if( verbose != 0 )
mbedtls_printf( " AES-ECB-%3d (%s): ", keybits,
( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memset( buf, 0, 16 );
if( mode == MBEDTLS_AES_DECRYPT )
{
ret = mbedtls_aes_setkey_dec( &ctx, key, keybits );
aes_tests = aes_test_ecb_dec[u];
}
else
{
ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
aes_tests = aes_test_ecb_enc[u];
}
/*
* AES-192 is an optional feature that may be unavailable when
* there is an alternative underlying implementation i.e. when
* MBEDTLS_AES_ALT is defined.
*/
if( ret == MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE && keybits == 192 )
{
mbedtls_printf( "skipped\n" );
continue;
}
else if( ret != 0 )
{
goto exit;
}
for( j = 0; j < 10000; j++ )
{
ret = mbedtls_aes_crypt_ecb( &ctx, mode, buf, buf );
if( ret != 0 )
goto exit;
}
if( memcmp( buf, aes_tests, 16 ) != 0 )
{
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* CBC mode
*/
for( i = 0; i < 6; i++ )
{
u = i >> 1;
keybits = 128 + u * 64;
mode = i & 1;
if( verbose != 0 )
mbedtls_printf( " AES-CBC-%3d (%s): ", keybits,
( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memset( iv , 0, 16 );
memset( prv, 0, 16 );
memset( buf, 0, 16 );
if( mode == MBEDTLS_AES_DECRYPT )
{
ret = mbedtls_aes_setkey_dec( &ctx, key, keybits );
aes_tests = aes_test_cbc_dec[u];
}
else
{
ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
aes_tests = aes_test_cbc_enc[u];
}
/*
* AES-192 is an optional feature that may be unavailable when
* there is an alternative underlying implementation i.e. when
* MBEDTLS_AES_ALT is defined.
*/
if( ret == MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE && keybits == 192 )
{
mbedtls_printf( "skipped\n" );
continue;
}
else if( ret != 0 )
{
goto exit;
}
for( j = 0; j < 10000; j++ )
{
if( mode == MBEDTLS_AES_ENCRYPT )
{
unsigned char tmp[16];
memcpy( tmp, prv, 16 );
memcpy( prv, buf, 16 );
memcpy( buf, tmp, 16 );
}
ret = mbedtls_aes_crypt_cbc( &ctx, mode, 16, iv, buf, buf );
if( ret != 0 )
goto exit;
}
if( memcmp( buf, aes_tests, 16 ) != 0 )
{
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
/*
* CFB128 mode
*/
for( i = 0; i < 6; i++ )
{
u = i >> 1;
keybits = 128 + u * 64;
mode = i & 1;
if( verbose != 0 )
mbedtls_printf( " AES-CFB128-%3d (%s): ", keybits,
( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memcpy( iv, aes_test_cfb128_iv, 16 );
memcpy( key, aes_test_cfb128_key[u], keybits / 8 );
offset = 0;
ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
/*
* AES-192 is an optional feature that may be unavailable when
* there is an alternative underlying implementation i.e. when
* MBEDTLS_AES_ALT is defined.
*/
if( ret == MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE && keybits == 192 )
{
mbedtls_printf( "skipped\n" );
continue;
}
else if( ret != 0 )
{
goto exit;
}
if( mode == MBEDTLS_AES_DECRYPT )
{
memcpy( buf, aes_test_cfb128_ct[u], 64 );
aes_tests = aes_test_cfb128_pt;
}
else
{
memcpy( buf, aes_test_cfb128_pt, 64 );
aes_tests = aes_test_cfb128_ct[u];
}
ret = mbedtls_aes_crypt_cfb128( &ctx, mode, 64, &offset, iv, buf, buf );
if( ret != 0 )
goto exit;
if( memcmp( buf, aes_tests, 64 ) != 0 )
{
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
/*
* CTR mode
*/
for( i = 0; i < 6; i++ )
{
u = i >> 1;
mode = i & 1;
if( verbose != 0 )
mbedtls_printf( " AES-CTR-128 (%s): ",
( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memcpy( nonce_counter, aes_test_ctr_nonce_counter[u], 16 );
memcpy( key, aes_test_ctr_key[u], 16 );
offset = 0;
if( ( ret = mbedtls_aes_setkey_enc( &ctx, key, 128 ) ) != 0 )
goto exit;
len = aes_test_ctr_len[u];
if( mode == MBEDTLS_AES_DECRYPT )
{
memcpy( buf, aes_test_ctr_ct[u], len );
aes_tests = aes_test_ctr_pt[u];
}
else
{
memcpy( buf, aes_test_ctr_pt[u], len );
aes_tests = aes_test_ctr_ct[u];
}
ret = mbedtls_aes_crypt_ctr( &ctx, len, &offset, nonce_counter,
stream_block, buf, buf );
if( ret != 0 )
goto exit;
if( memcmp( buf, aes_tests, len ) != 0 )
{
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
#endif /* MBEDTLS_CIPHER_MODE_CTR */
ret = 0;
exit:
if( ret != 0 && verbose != 0 )
mbedtls_printf( "failed\n" );
mbedtls_aes_free( &ctx );
return( ret );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movl %edi, 0xc(%rsp)
pxor %xmm0, %xmm0
leaq 0x70(%rsp), %rax
movdqa %xmm0, (%rax)
movdqa %xmm0, 0x10(%rax)
leaq 0xc0(%rsp), %rdi
movl $0x120, %edx # imm = 0x120
xorl %esi, %esi
callq 0x20c0
leaq 0x20(%rsp), %r13
xorl %r15d, %r15d
cmpl $0x6, %r15d
je 0x58d6
movl %r15d, %r14d
shrl %r14d
movl %r14d, %ebx
shll $0x6, %ebx
subl $-0x80, %ebx
movl %r15d, %ebp
andl $0x1, %ebp
cmpl $0x0, 0xc(%rsp)
je 0x5805
testl %ebp, %ebp
leaq 0x217f(%rip), %rdx # 0x7969
leaq 0x2174(%rip), %rax # 0x7965
cmoveq %rax, %rdx
leaq 0x2154(%rip), %rdi # 0x7950
movl %ebx, %esi
xorl %eax, %eax
callq 0x2090
pxor %xmm0, %xmm0
movdqa %xmm0, 0x20(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movl %ebx, %edx
testl %ebp, %ebp
jne 0x5833
callq 0x4a05
movl %eax, %r12d
leaq 0x219f(%rip), %rax # 0x79d0
jmp 0x5842
callq 0x4443
movl %eax, %r12d
leaq 0x21be(%rip), %rax # 0x7a00
movq %rax, 0x10(%rsp)
movl %r12d, %eax
xorl $-0x23, %eax
xorl $0xc0, %ebx
orl %eax, %ebx
leaq 0x2161(%rip), %rdi # 0x79bd
je 0x58c9
testl %r12d, %r12d
jne 0x5d36
movl %r14d, %eax
shlq $0x4, %rax
addq %rax, 0x10(%rsp)
movl $0x2711, %ebx # imm = 0x2711
leaq 0xc0(%rsp), %r14
decl %ebx
je 0x589d
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movq %r13, %rcx
callq 0x5466
testl %eax, %eax
je 0x5880
jmp 0x5d33
movq 0x10(%rsp), %rax
movdqu (%rax), %xmm0
pcmpeqb 0x20(%rsp), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x5d6b
leaq 0x20ed(%rip), %rdi # 0x79af
cmpl $0x0, 0xc(%rsp)
je 0x58ce
callq 0x2060
incl %r15d
jmp 0x57bb
cmpl $0x0, 0xc(%rsp)
je 0x58e5
pushq $0xa
popq %rdi
callq 0x2040
xorl %ebp, %ebp
cmpl $0x6, %ebp
je 0x5a3a
movl %ebp, %ebx
shrl %ebx
movl %ebx, %r13d
shll $0x6, %r13d
subl $-0x80, %r13d
movl %ebp, %r14d
andl $0x1, %r14d
cmpl $0x0, 0xc(%rsp)
je 0x5933
testl %r14d, %r14d
leaq 0x2052(%rip), %rdx # 0x7969
leaq 0x2047(%rip), %rax # 0x7965
cmoveq %rax, %rdx
leaq 0x2044(%rip), %rdi # 0x796d
movl %r13d, %esi
xorl %eax, %eax
callq 0x2090
pxor %xmm0, %xmm0
movdqa %xmm0, 0x60(%rsp)
movdqa %xmm0, 0x90(%rsp)
movdqa %xmm0, 0x20(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movl %r13d, %edx
testl %r14d, %r14d
jne 0x5972
callq 0x4a05
movl %eax, %r12d
leaq 0x20c0(%rip), %r15 # 0x7a30
jmp 0x5981
callq 0x4443
movl %eax, %r12d
leaq 0x20df(%rip), %r15 # 0x7a60
movl %r12d, %eax
xorl $-0x23, %eax
xorl $0xc0, %r13d
orl %eax, %r13d
leaq 0x2025(%rip), %rdi # 0x79bd
leaq 0x20(%rsp), %r13
je 0x5a2e
testl %r12d, %r12d
jne 0x5d36
movl %ebx, %eax
shlq $0x4, %rax
addq %rax, %r15
movl $0x2711, %ebx # imm = 0x2711
decl %ebx
je 0x5a06
testl %r14d, %r14d
je 0x59df
movdqa 0x90(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movaps %xmm1, 0x90(%rsp)
movdqa %xmm0, 0x20(%rsp)
leaq 0xc0(%rsp), %rdi
movl %r14d, %esi
pushq $0x10
popq %rdx
leaq 0x60(%rsp), %rcx
movq %r13, %r8
movq %r13, %r9
callq 0x54c4
testl %eax, %eax
je 0x59ba
jmp 0x5d33
movdqu (%r15), %xmm0
pcmpeqb 0x20(%rsp), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x5d6b
leaq 0x1f88(%rip), %rdi # 0x79af
cmpl $0x0, 0xc(%rsp)
je 0x5a33
callq 0x2060
incl %ebp
jmp 0x58e7
cmpl $0x0, 0xc(%rsp)
je 0x5a49
pushq $0xa
popq %rdi
callq 0x2040
leaq 0x70(%rsp), %r15
xorl %ebp, %ebp
cmpl $0x6, %ebp
je 0x5bea
movl %ebp, %r12d
shrl %r12d
movl %r12d, %ebx
shll $0x6, %ebx
subl $-0x80, %ebx
movl %ebp, %r14d
andl $0x1, %r14d
cmpl $0x0, 0xc(%rsp)
je 0x5a9b
testl %r14d, %r14d
leaq 0x1ee9(%rip), %rdx # 0x7969
leaq 0x1ede(%rip), %rax # 0x7965
cmoveq %rax, %rdx
leaq 0x1ef0(%rip), %rdi # 0x7982
movl %ebx, %esi
xorl %eax, %eax
callq 0x2090
movdqa 0x1e9d(%rip), %xmm0 # 0x7940
movdqa %xmm0, 0x60(%rsp)
movl %r12d, %r13d
movq %r13, %rsi
shlq $0x5, %rsi
leaq 0x2146(%rip), %rax # 0x7c00
addq %rax, %rsi
movl %ebx, %edx
shrl $0x3, %edx
movq %r15, %rdi
callq 0x2130
andq $0x0, 0x18(%rsp)
leaq 0xc0(%rsp), %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x4443
movl %eax, %r12d
xorl $-0x23, %eax
xorl $0xc0, %ebx
orl %eax, %ebx
leaq 0x1ec6(%rip), %rdi # 0x79bd
je 0x5bde
testl %r12d, %r12d
jne 0x5d36
testl %r14d, %r14d
jne 0x5b4d
shlq $0x6, %r13
leaq 0x1f7a(%rip), %rax # 0x7a90
movdqa (%r13,%rax), %xmm0
movaps 0x10(%r13,%rax), %xmm1
movaps 0x20(%r13,%rax), %xmm2
movaps 0x30(%r13,%rax), %xmm3
movaps %xmm3, 0x50(%rsp)
movaps %xmm2, 0x40(%rsp)
movaps %xmm1, 0x30(%rsp)
movdqa %xmm0, 0x20(%rsp)
leaq 0x2005(%rip), %r13 # 0x7b50
jmp 0x5b8d
movaps 0x202c(%rip), %xmm0 # 0x7b80
movaps %xmm0, 0x50(%rsp)
movaps 0x2010(%rip), %xmm0 # 0x7b70
movaps %xmm0, 0x40(%rsp)
movaps 0x1ff4(%rip), %xmm0 # 0x7b60
movaps %xmm0, 0x30(%rsp)
movdqa 0x1fd7(%rip), %xmm0 # 0x7b50
movdqa %xmm0, 0x20(%rsp)
shlq $0x6, %r13
leaq 0x1f06(%rip), %rax # 0x7a90
addq %rax, %r13
leaq 0x20(%rsp), %rbx
movq %rbx, (%rsp)
leaq 0xc0(%rsp), %rdi
movl %r14d, %esi
pushq $0x40
popq %r14
movq %r14, %rdx
leaq 0x18(%rsp), %rcx
leaq 0x60(%rsp), %r8
movq %rbx, %r9
callq 0x5596
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2160
testl %eax, %eax
jne 0x5d6b
leaq 0x1dd8(%rip), %rdi # 0x79af
cmpl $0x0, 0xc(%rsp)
je 0x5be3
callq 0x2060
incl %ebp
jmp 0x5a50
cmpl $0x0, 0xc(%rsp)
je 0x5bf9
pushq $0xa
popq %rdi
callq 0x2040
leaq 0xc0(%rsp), %r13
xorl %r14d, %r14d
cmpl $0x6, %r14d
je 0x5d71
cmpl $0x0, 0xc(%rsp)
je 0x5c39
testb $0x1, %r14b
leaq 0x1d49(%rip), %rsi # 0x7969
leaq 0x1d3e(%rip), %rax # 0x7965
cmoveq %rax, %rsi
leaq 0x1d68(%rip), %rdi # 0x799a
xorl %eax, %eax
callq 0x2090
movl %r14d, %eax
shrl %eax
movl %eax, %r15d
movq %r15, %rax
shlq $0x4, %rax
leaq 0x1f41(%rip), %rcx # 0x7b90
movaps (%rax,%rcx), %xmm0
movaps %xmm0, 0xa0(%rsp)
leaq 0x1f5e(%rip), %rcx # 0x7bc0
movdqa (%rax,%rcx), %xmm0
movdqa %xmm0, 0x70(%rsp)
andq $0x0, 0x18(%rsp)
movq %r13, %rdi
leaq 0x70(%rsp), %rsi
movl $0x80, %edx
callq 0x4443
testl %eax, %eax
jne 0x5d33
leaq 0x1f5c(%rip), %rax # 0x7bf0
movslq (%rax,%r15,4), %rbx
movl %r14d, 0x10(%rsp)
testb $0x1, %r14b
leaq 0x2048(%rip), %rax # 0x7cf0
movq %rax, %rsi
leaq 0x1fae(%rip), %r12 # 0x7c60
cmoveq %r12, %rsi
cmoveq %rax, %r12
imulq $0x30, %r15, %r15
addq %r15, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2130
movq %r14, (%rsp)
movq %r13, %rbp
movq %r13, %rdi
movq %rbx, %rsi
leaq 0x18(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
leaq 0xb0(%rsp), %r8
movq %r14, %r9
callq 0x56e8
addq %r15, %r12
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2160
testl %eax, %eax
jne 0x5d6b
cmpl $0x0, 0xc(%rsp)
je 0x5d23
leaq 0x1c91(%rip), %rdi # 0x79af
callq 0x2060
movl 0x10(%rsp), %r14d
incl %r14d
movq %rbp, %r13
jmp 0x5c04
movl %eax, %r12d
cmpl $0x0, 0xc(%rsp)
je 0x5d49
leaq 0x1c72(%rip), %rdi # 0x79b6
callq 0x2060
leaq 0xc0(%rsp), %rdi
callq 0x4424
movl %r12d, %eax
addq $0x1f8, %rsp # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %r12
jmp 0x5d36
xorl %r12d, %r12d
cmpl $0x0, 0xc(%rsp)
je 0x5d49
pushq $0xa
popq %rdi
callq 0x2040
jmp 0x5d49
nopl (%rax)
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_aesni_has_support | int mbedtls_aesni_has_support( unsigned int what )
{
static int done = 0;
static unsigned int c = 0;
if( ! done )
{
asm( "movl $1, %%eax \n\t"
"cpuid \n\t"
: "=c" (c)
:
: "eax", "ebx", "edx" );
done = 1;
}
return( ( c & what ) != 0 );
} | cmpb $0x1, 0x65d1(%rip) # 0xc360
jne 0x5d99
movl 0x65cd(%rip), %ecx # 0xc364
jmp 0x5daf
pushq %rbx
movl $0x1, %eax
cpuid
movl %ecx, 0x65bd(%rip) # 0xc364
movb $0x1, 0x65b2(%rip) # 0xc360
popq %rbx
xorl %eax, %eax
testl %edi, %ecx
setne %al
retq
| /project-everest[P]mbedtls/library/aesni.c |
mbedtls_aesni_crypt_ecb | int mbedtls_aesni_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
asm( "movdqu (%3), %%xmm0 \n\t" // load input
"movdqu (%1), %%xmm1 \n\t" // load round key 0
"pxor %%xmm1, %%xmm0 \n\t" // round 0
"add $16, %1 \n\t" // point to next round key
"subl $1, %0 \n\t" // normal rounds = nr - 1
"test %2, %2 \n\t" // mode?
"jz 2f \n\t" // 0 = decrypt
"1: \n\t" // encryption loop
"movdqu (%1), %%xmm1 \n\t" // load round key
AESENC xmm1_xmm0 "\n\t" // do round
"add $16, %1 \n\t" // point to next round key
"subl $1, %0 \n\t" // loop
"jnz 1b \n\t"
"movdqu (%1), %%xmm1 \n\t" // load round key
AESENCLAST xmm1_xmm0 "\n\t" // last round
"jmp 3f \n\t"
"2: \n\t" // decryption loop
"movdqu (%1), %%xmm1 \n\t"
AESDEC xmm1_xmm0 "\n\t" // do round
"add $16, %1 \n\t"
"subl $1, %0 \n\t"
"jnz 2b \n\t"
"movdqu (%1), %%xmm1 \n\t" // load round key
AESDECLAST xmm1_xmm0 "\n\t" // last round
"3: \n\t"
"movdqu %%xmm0, (%4) \n\t" // export output
:
: "r" (ctx->nr), "r" (ctx->rk), "r" (mode), "r" (input), "r" (output)
: "memory", "cc", "xmm0", "xmm1" );
return( 0 );
} | movl (%rdi), %eax
movq 0x8(%rdi), %rdi
movdqu (%rdx), %xmm0
movdqu (%rdi), %xmm1
pxor %xmm1, %xmm0
addq $0x10, %rdi
subl $0x1, %eax
testl %esi, %esi
je 0x5df1
movdqu (%rdi), %xmm1
aesenc %xmm1, %xmm0
addq $0x10, %rdi
subl $0x1, %eax
jne 0x5dd4
movdqu (%rdi), %xmm1
aesenclast %xmm1, %xmm0
jmp 0x5e0c
movdqu (%rdi), %xmm1
aesdec %xmm1, %xmm0
addq $0x10, %rdi
subl $0x1, %eax
jne 0x5df1
movdqu (%rdi), %xmm1
aesdeclast %xmm1, %xmm0
movdqu %xmm0, (%rcx)
xorl %eax, %eax
retq
| /project-everest[P]mbedtls/library/aesni.c |
mbedtls_aesni_gcm_mult | void mbedtls_aesni_gcm_mult( unsigned char c[16],
const unsigned char a[16],
const unsigned char b[16] )
{
unsigned char aa[16], bb[16], cc[16];
size_t i;
/* The inputs are in big-endian order, so byte-reverse them */
for( i = 0; i < 16; i++ )
{
aa[i] = a[15 - i];
bb[i] = b[15 - i];
}
asm( "movdqu (%0), %%xmm0 \n\t" // a1:a0
"movdqu (%1), %%xmm1 \n\t" // b1:b0
/*
* Caryless multiplication xmm2:xmm1 = xmm0 * xmm1
* using [CLMUL-WP] algorithm 1 (p. 13).
*/
"movdqa %%xmm1, %%xmm2 \n\t" // copy of b1:b0
"movdqa %%xmm1, %%xmm3 \n\t" // same
"movdqa %%xmm1, %%xmm4 \n\t" // same
PCLMULQDQ xmm0_xmm1 ",0x00 \n\t" // a0*b0 = c1:c0
PCLMULQDQ xmm0_xmm2 ",0x11 \n\t" // a1*b1 = d1:d0
PCLMULQDQ xmm0_xmm3 ",0x10 \n\t" // a0*b1 = e1:e0
PCLMULQDQ xmm0_xmm4 ",0x01 \n\t" // a1*b0 = f1:f0
"pxor %%xmm3, %%xmm4 \n\t" // e1+f1:e0+f0
"movdqa %%xmm4, %%xmm3 \n\t" // same
"psrldq $8, %%xmm4 \n\t" // 0:e1+f1
"pslldq $8, %%xmm3 \n\t" // e0+f0:0
"pxor %%xmm4, %%xmm2 \n\t" // d1:d0+e1+f1
"pxor %%xmm3, %%xmm1 \n\t" // c1+e0+f1:c0
/*
* Now shift the result one bit to the left,
* taking advantage of [CLMUL-WP] eq 27 (p. 20)
*/
"movdqa %%xmm1, %%xmm3 \n\t" // r1:r0
"movdqa %%xmm2, %%xmm4 \n\t" // r3:r2
"psllq $1, %%xmm1 \n\t" // r1<<1:r0<<1
"psllq $1, %%xmm2 \n\t" // r3<<1:r2<<1
"psrlq $63, %%xmm3 \n\t" // r1>>63:r0>>63
"psrlq $63, %%xmm4 \n\t" // r3>>63:r2>>63
"movdqa %%xmm3, %%xmm5 \n\t" // r1>>63:r0>>63
"pslldq $8, %%xmm3 \n\t" // r0>>63:0
"pslldq $8, %%xmm4 \n\t" // r2>>63:0
"psrldq $8, %%xmm5 \n\t" // 0:r1>>63
"por %%xmm3, %%xmm1 \n\t" // r1<<1|r0>>63:r0<<1
"por %%xmm4, %%xmm2 \n\t" // r3<<1|r2>>62:r2<<1
"por %%xmm5, %%xmm2 \n\t" // r3<<1|r2>>62:r2<<1|r1>>63
/*
* Now reduce modulo the GCM polynomial x^128 + x^7 + x^2 + x + 1
* using [CLMUL-WP] algorithm 5 (p. 20).
* Currently xmm2:xmm1 holds x3:x2:x1:x0 (already shifted).
*/
/* Step 2 (1) */
"movdqa %%xmm1, %%xmm3 \n\t" // x1:x0
"movdqa %%xmm1, %%xmm4 \n\t" // same
"movdqa %%xmm1, %%xmm5 \n\t" // same
"psllq $63, %%xmm3 \n\t" // x1<<63:x0<<63 = stuff:a
"psllq $62, %%xmm4 \n\t" // x1<<62:x0<<62 = stuff:b
"psllq $57, %%xmm5 \n\t" // x1<<57:x0<<57 = stuff:c
/* Step 2 (2) */
"pxor %%xmm4, %%xmm3 \n\t" // stuff:a+b
"pxor %%xmm5, %%xmm3 \n\t" // stuff:a+b+c
"pslldq $8, %%xmm3 \n\t" // a+b+c:0
"pxor %%xmm3, %%xmm1 \n\t" // x1+a+b+c:x0 = d:x0
/* Steps 3 and 4 */
"movdqa %%xmm1,%%xmm0 \n\t" // d:x0
"movdqa %%xmm1,%%xmm4 \n\t" // same
"movdqa %%xmm1,%%xmm5 \n\t" // same
"psrlq $1, %%xmm0 \n\t" // e1:x0>>1 = e1:e0'
"psrlq $2, %%xmm4 \n\t" // f1:x0>>2 = f1:f0'
"psrlq $7, %%xmm5 \n\t" // g1:x0>>7 = g1:g0'
"pxor %%xmm4, %%xmm0 \n\t" // e1+f1:e0'+f0'
"pxor %%xmm5, %%xmm0 \n\t" // e1+f1+g1:e0'+f0'+g0'
// e0'+f0'+g0' is almost e0+f0+g0, ex\tcept for some missing
// bits carried from d. Now get those\t bits back in.
"movdqa %%xmm1,%%xmm3 \n\t" // d:x0
"movdqa %%xmm1,%%xmm4 \n\t" // same
"movdqa %%xmm1,%%xmm5 \n\t" // same
"psllq $63, %%xmm3 \n\t" // d<<63:stuff
"psllq $62, %%xmm4 \n\t" // d<<62:stuff
"psllq $57, %%xmm5 \n\t" // d<<57:stuff
"pxor %%xmm4, %%xmm3 \n\t" // d<<63+d<<62:stuff
"pxor %%xmm5, %%xmm3 \n\t" // missing bits of d:stuff
"psrldq $8, %%xmm3 \n\t" // 0:missing bits of d
"pxor %%xmm3, %%xmm0 \n\t" // e1+f1+g1:e0+f0+g0
"pxor %%xmm1, %%xmm0 \n\t" // h1:h0
"pxor %%xmm2, %%xmm0 \n\t" // x3+h1:x2+h0
"movdqu %%xmm0, (%2) \n\t" // done
:
: "r" (aa), "r" (bb), "r" (cc)
: "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5" );
/* Now byte-reverse the outputs */
for( i = 0; i < 16; i++ )
c[i] = cc[15 - i];
return;
} | movabsq $0x10, %rcx
xorl %eax, %eax
movq %rcx, %r8
subq $0x1, %r8
jb 0x5e42
movb -0x1(%rsi,%rcx), %r9b
movb %r9b, -0x18(%rsp,%rax)
movb -0x1(%rdx,%rcx), %cl
movb %cl, -0x28(%rsp,%rax)
incq %rax
movq %r8, %rcx
jmp 0x5e22
leaq -0x18(%rsp), %rax
leaq -0x28(%rsp), %rcx
leaq -0x38(%rsp), %rdx
movdqu (%rax), %xmm0
movdqu (%rcx), %xmm1
movdqa %xmm1, %xmm2
movdqa %xmm1, %xmm3
movdqa %xmm1, %xmm4
pclmulqdq $0x0, %xmm0, %xmm1
pclmulqdq $0x11, %xmm0, %xmm2
pclmulqdq $0x10, %xmm0, %xmm3
pclmulqdq $0x1, %xmm0, %xmm4
pxor %xmm3, %xmm4
movdqa %xmm4, %xmm3
psrldq $0x8, %xmm4 # xmm4 = xmm4[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
pslldq $0x8, %xmm3 # xmm3 = zero,zero,zero,zero,zero,zero,zero,zero,xmm3[0,1,2,3,4,5,6,7]
pxor %xmm4, %xmm2
pxor %xmm3, %xmm1
movdqa %xmm1, %xmm3
movdqa %xmm2, %xmm4
psllq $0x1, %xmm1
psllq $0x1, %xmm2
psrlq $0x3f, %xmm3
psrlq $0x3f, %xmm4
movdqa %xmm3, %xmm5
pslldq $0x8, %xmm3 # xmm3 = zero,zero,zero,zero,zero,zero,zero,zero,xmm3[0,1,2,3,4,5,6,7]
pslldq $0x8, %xmm4 # xmm4 = zero,zero,zero,zero,zero,zero,zero,zero,xmm4[0,1,2,3,4,5,6,7]
psrldq $0x8, %xmm5 # xmm5 = xmm5[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
por %xmm3, %xmm1
por %xmm4, %xmm2
por %xmm5, %xmm2
movdqa %xmm1, %xmm3
movdqa %xmm1, %xmm4
movdqa %xmm1, %xmm5
psllq $0x3f, %xmm3
psllq $0x3e, %xmm4
psllq $0x39, %xmm5
pxor %xmm4, %xmm3
pxor %xmm5, %xmm3
pslldq $0x8, %xmm3 # xmm3 = zero,zero,zero,zero,zero,zero,zero,zero,xmm3[0,1,2,3,4,5,6,7]
pxor %xmm3, %xmm1
movdqa %xmm1, %xmm0
movdqa %xmm1, %xmm4
movdqa %xmm1, %xmm5
psrlq $0x1, %xmm0
psrlq $0x2, %xmm4
psrlq $0x7, %xmm5
pxor %xmm4, %xmm0
pxor %xmm5, %xmm0
movdqa %xmm1, %xmm3
movdqa %xmm1, %xmm4
movdqa %xmm1, %xmm5
psllq $0x3f, %xmm3
psllq $0x3e, %xmm4
psllq $0x39, %xmm5
pxor %xmm4, %xmm3
pxor %xmm5, %xmm3
psrldq $0x8, %xmm3 # xmm3 = xmm3[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
pxor %xmm3, %xmm0
pxor %xmm1, %xmm0
pxor %xmm2, %xmm0
movdqu %xmm0, (%rdx)
movabsq $0x10, %rcx
movq %rcx, %rax
subq $0x1, %rax
jb 0x5f7a
movb -0x39(%rsp,%rcx), %cl
movb %cl, (%rdi)
incq %rdi
movq %rax, %rcx
jmp 0x5f66
retq
| /project-everest[P]mbedtls/library/aesni.c |
mbedtls_aesni_inverse_key | void mbedtls_aesni_inverse_key( unsigned char *invkey,
const unsigned char *fwdkey, int nr )
{
unsigned char *ik = invkey;
const unsigned char *fk = fwdkey + 16 * nr;
memcpy( ik, fk, 16 );
for( fk -= 16, ik += 16; fk > fwdkey; fk -= 16, ik += 16 )
asm( "movdqu (%0), %%xmm0 \n\t"
AESIMC xmm0_xmm0 "\n\t"
"movdqu %%xmm0, (%1) \n\t"
:
: "r" (fk), "r" (ik)
: "memory", "xmm0" );
memcpy( ik, fk, 16 );
} | shll $0x4, %edx
movslq %edx, %rax
addq %rsi, %rax
addq $-0x10, %rax
movups 0x10(%rax), %xmm0
movups %xmm0, (%rdi)
addq $0x10, %rdi
cmpq %rsi, %rax
jbe 0x5faf
movdqu (%rax), %xmm0
aesimc %xmm0, %xmm0
movdqu %xmm0, (%rdi)
addq $0x10, %rdi
addq $-0x10, %rax
jmp 0x5f93
movups (%rax), %xmm0
movups %xmm0, (%rdi)
retq
| /project-everest[P]mbedtls/library/aesni.c |
mbedtls_aesni_setkey_enc | int mbedtls_aesni_setkey_enc( unsigned char *rk,
const unsigned char *key,
size_t bits )
{
switch( bits )
{
case 128: aesni_setkey_enc_128( rk, key ); break;
case 192: aesni_setkey_enc_192( rk, key ); break;
case 256: aesni_setkey_enc_256( rk, key ); break;
default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
}
return( 0 );
} | cmpq $0x100, %rdx # imm = 0x100
je 0x6146
cmpq $0xc0, %rdx
je 0x6087
cmpq $0x80, %rdx
jne 0x620c
movdqu (%rsi), %xmm0
movdqu %xmm0, (%rdi)
jmp 0x6014
pshufd $0xff, %xmm1, %xmm1 # xmm1 = xmm1[3,3,3,3]
pxor %xmm0, %xmm1
pslldq $0x4, %xmm0 # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm0, %xmm1
pslldq $0x4, %xmm0 # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm0, %xmm1
pslldq $0x4, %xmm0 # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm1, %xmm0
addq $0x10, %rdi
movdqu %xmm0, (%rdi)
retq
aeskeygenassist $0x1, %xmm0, %xmm1
callq 0x5fe7
aeskeygenassist $0x2, %xmm0, %xmm1
callq 0x5fe7
aeskeygenassist $0x4, %xmm0, %xmm1
callq 0x5fe7
aeskeygenassist $0x8, %xmm0, %xmm1
callq 0x5fe7
aeskeygenassist $0x10, %xmm0, %xmm1
callq 0x5fe7
aeskeygenassist $0x20, %xmm0, %xmm1
callq 0x5fe7
aeskeygenassist $0x40, %xmm0, %xmm1
callq 0x5fe7
aeskeygenassist $0x80, %xmm0, %xmm1
callq 0x5fe7
aeskeygenassist $0x1b, %xmm0, %xmm1
callq 0x5fe7
aeskeygenassist $0x36, %xmm0, %xmm1
callq 0x5fe7
jmp 0x6209
movdqu (%rsi), %xmm0
movdqu %xmm0, (%rdi)
addq $0x10, %rdi
movq 0x10(%rsi), %xmm1
movq %xmm1, (%rdi)
addq $0x8, %rdi
jmp 0x60e9
pshufd $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
pxor %xmm0, %xmm2
pslldq $0x4, %xmm0 # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm0, %xmm2
pslldq $0x4, %xmm0 # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm0, %xmm2
pslldq $0x4, %xmm0 # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm2, %xmm0
movdqu %xmm0, (%rdi)
addq $0x10, %rdi
pshufd $0xff, %xmm0, %xmm2 # xmm2 = xmm0[3,3,3,3]
pxor %xmm1, %xmm2
pslldq $0x4, %xmm1 # xmm1 = zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm2, %xmm1
movq %xmm1, (%rdi)
addq $0x8, %rdi
retq
aeskeygenassist $0x1, %xmm1, %xmm2
callq 0x60a2
aeskeygenassist $0x2, %xmm1, %xmm2
callq 0x60a2
aeskeygenassist $0x4, %xmm1, %xmm2
callq 0x60a2
aeskeygenassist $0x8, %xmm1, %xmm2
callq 0x60a2
aeskeygenassist $0x10, %xmm1, %xmm2
callq 0x60a2
aeskeygenassist $0x20, %xmm1, %xmm2
callq 0x60a2
aeskeygenassist $0x40, %xmm1, %xmm2
callq 0x60a2
aeskeygenassist $0x80, %xmm1, %xmm2
callq 0x60a2
jmp 0x6209
movdqu (%rsi), %xmm0
movdqu %xmm0, (%rdi)
addq $0x10, %rdi
movdqu 0x10(%rsi), %xmm1
movdqu %xmm1, (%rdi)
jmp 0x61bc
pshufd $0xff, %xmm2, %xmm2 # xmm2 = xmm2[3,3,3,3]
pxor %xmm0, %xmm2
pslldq $0x4, %xmm0 # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm0, %xmm2
pslldq $0x4, %xmm0 # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm0, %xmm2
pslldq $0x4, %xmm0 # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm2, %xmm0
addq $0x10, %rdi
movdqu %xmm0, (%rdi)
aeskeygenassist $0x0, %xmm0, %xmm2
pshufd $0xaa, %xmm2, %xmm2 # xmm2 = xmm2[2,2,2,2]
pxor %xmm1, %xmm2
pslldq $0x4, %xmm1 # xmm1 = zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm1, %xmm2
pslldq $0x4, %xmm1 # xmm1 = zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm1, %xmm2
pslldq $0x4, %xmm1 # xmm1 = zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
pxor %xmm2, %xmm1
addq $0x10, %rdi
movdqu %xmm1, (%rdi)
retq
aeskeygenassist $0x1, %xmm1, %xmm2
callq 0x615d
aeskeygenassist $0x2, %xmm1, %xmm2
callq 0x615d
aeskeygenassist $0x4, %xmm1, %xmm2
callq 0x615d
aeskeygenassist $0x8, %xmm1, %xmm2
callq 0x615d
aeskeygenassist $0x10, %xmm1, %xmm2
callq 0x615d
aeskeygenassist $0x20, %xmm1, %xmm2
callq 0x615d
aeskeygenassist $0x40, %xmm1, %xmm2
callq 0x615d
xorl %eax, %eax
retq
pushq $-0x20
popq %rax
retq
| /project-everest[P]mbedtls/library/aesni.c |
mbedtls_gcm_finish | int mbedtls_gcm_finish( mbedtls_gcm_context *ctx,
unsigned char *tag,
size_t tag_len )
{
unsigned char work_buf[16];
size_t i;
uint64_t orig_len = ctx->len * 8;
uint64_t orig_add_len = ctx->add_len * 8;
if( tag_len > 16 || tag_len < 4 )
return( MBEDTLS_ERR_GCM_BAD_INPUT );
memcpy( tag, ctx->base_ectr, tag_len );
if( orig_len || orig_add_len )
{
memset( work_buf, 0x00, 16 );
PUT_UINT32_BE( ( orig_add_len >> 32 ), work_buf, 0 );
PUT_UINT32_BE( ( orig_add_len ), work_buf, 4 );
PUT_UINT32_BE( ( orig_len >> 32 ), work_buf, 8 );
PUT_UINT32_BE( ( orig_len ), work_buf, 12 );
for( i = 0; i < 16; i++ )
ctx->buf[i] ^= work_buf[i];
gcm_mult( ctx, ctx->buf, ctx->buf );
for( i = 0; i < tag_len; i++ )
tag[i] ^= ctx->buf[i];
}
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq -0x11(%rdx), %rax
movl $0xffffffec, %r15d # imm = 0xFFFFFFEC
cmpq $-0xd, %rax
jb 0x61f1
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x158(%rdi), %rbp
movq 0x160(%rdi), %r13
shlq $0x3, %rbp
shlq $0x3, %r13
leaq 0x168(%rdi), %rsi
movq %r14, %rdi
callq 0x4140
xorl %r15d, %r15d
movq %rbp, %rax
orq %r13, %rax
je 0x61f1
movq %rbp, %rdx
movq %rbp, %rax
movq %rbp, %rcx
movq %rbp, %rsi
movl %ebp, %edi
movl %ebp, %r8d
movd %ebp, %xmm0
shrl $0x8, %ebp
movd %ebp, %xmm1
shrl $0x10, %r8d
movd %r8d, %xmm4
shrl $0x18, %edi
movd %edi, %xmm2
shrq $0x20, %rdx
movd %edx, %xmm5
shrq $0x28, %rsi
movd %esi, %xmm6
shrq $0x30, %rcx
movd %ecx, %xmm7
shrq $0x38, %rax
movd %eax, %xmm3
movl %r13d, %eax
shrl $0x8, %eax
movd %eax, %xmm9
movl %r13d, %eax
shrl $0x10, %eax
movd %eax, %xmm10
movl %r13d, %eax
shrl $0x18, %eax
movd %eax, %xmm8
movq %r13, %rax
shrq $0x20, %rax
movd %eax, %xmm11
movq %r13, %rax
shrq $0x28, %rax
movd %eax, %xmm12
movq %r13, %rax
shrq $0x30, %rax
movd %eax, %xmm13
punpcklbw %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
punpcklbw %xmm4, %xmm2 # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1],xmm2[2],xmm4[2],xmm2[3],xmm4[3],xmm2[4],xmm4[4],xmm2[5],xmm4[5],xmm2[6],xmm4[6],xmm2[7],xmm4[7]
punpcklwd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3]
punpcklbw %xmm5, %xmm6 # xmm6 = xmm6[0],xmm5[0],xmm6[1],xmm5[1],xmm6[2],xmm5[2],xmm6[3],xmm5[3],xmm6[4],xmm5[4],xmm6[5],xmm5[5],xmm6[6],xmm5[6],xmm6[7],xmm5[7]
punpcklbw %xmm7, %xmm3 # xmm3 = xmm3[0],xmm7[0],xmm3[1],xmm7[1],xmm3[2],xmm7[2],xmm3[3],xmm7[3],xmm3[4],xmm7[4],xmm3[5],xmm7[5],xmm3[6],xmm7[6],xmm3[7],xmm7[7]
punpcklwd %xmm6, %xmm3 # xmm3 = xmm3[0],xmm6[0],xmm3[1],xmm6[1],xmm3[2],xmm6[2],xmm3[3],xmm6[3]
punpckldq %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movd %r13d, %xmm0
punpcklbw %xmm0, %xmm9 # xmm9 = xmm9[0],xmm0[0],xmm9[1],xmm0[1],xmm9[2],xmm0[2],xmm9[3],xmm0[3],xmm9[4],xmm0[4],xmm9[5],xmm0[5],xmm9[6],xmm0[6],xmm9[7],xmm0[7]
punpcklbw %xmm10, %xmm8 # xmm8 = xmm8[0],xmm10[0],xmm8[1],xmm10[1],xmm8[2],xmm10[2],xmm8[3],xmm10[3],xmm8[4],xmm10[4],xmm8[5],xmm10[5],xmm8[6],xmm10[6],xmm8[7],xmm10[7]
punpcklwd %xmm9, %xmm8 # xmm8 = xmm8[0],xmm9[0],xmm8[1],xmm9[1],xmm8[2],xmm9[2],xmm8[3],xmm9[3]
shrq $0x38, %r13
punpcklbw %xmm11, %xmm12 # xmm12 = xmm12[0],xmm11[0],xmm12[1],xmm11[1],xmm12[2],xmm11[2],xmm12[3],xmm11[3],xmm12[4],xmm11[4],xmm12[5],xmm11[5],xmm12[6],xmm11[6],xmm12[7],xmm11[7]
movd %r13d, %xmm0
punpcklbw %xmm13, %xmm0 # xmm0 = xmm0[0],xmm13[0],xmm0[1],xmm13[1],xmm0[2],xmm13[2],xmm0[3],xmm13[3],xmm0[4],xmm13[4],xmm0[5],xmm13[5],xmm0[6],xmm13[6],xmm0[7],xmm13[7]
punpcklwd %xmm12, %xmm0 # xmm0 = xmm0[0],xmm12[0],xmm0[1],xmm12[1],xmm0[2],xmm12[2],xmm0[3],xmm12[3]
punpckldq %xmm8, %xmm0 # xmm0 = xmm0[0],xmm8[0],xmm0[1],xmm8[1]
punpcklqdq %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0]
leaq 0x188(%r12), %r13
movdqu 0x188(%r12), %xmm1
pxor %xmm0, %xmm1
movdqu %xmm1, 0x188(%r12)
movq %r12, %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x5db9
testq %rbx, %rbx
je 0x61f1
xorl %r15d, %r15d
xorl %eax, %eax
movb (%r13,%rax), %cl
xorb %cl, (%r14,%rax)
incq %rax
cmpq %rax, %rbx
jne 0x61e0
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/gcm.c |
mbedtls_gcm_crypt_and_tag | int mbedtls_gcm_crypt_and_tag( mbedtls_gcm_context *ctx,
int mode,
size_t length,
const unsigned char *iv,
size_t iv_len,
const unsigned char *add,
size_t add_len,
const unsigned char *input,
unsigned char *output,
size_t tag_len,
unsigned char *tag )
{
int ret;
if( ( ret = mbedtls_gcm_starts( ctx, mode, iv, iv_len, add, add_len ) ) != 0 )
return( ret );
if( ( ret = mbedtls_gcm_update( ctx, length, input, output ) ) != 0 )
return( ret );
if( ( ret = mbedtls_gcm_finish( ctx, tag, tag_len ) ) != 0 )
return( ret );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rax
movq %rdx, %r12
movq %rdi, %rbx
movq 0x60(%rsp), %r15
movq 0x58(%rsp), %r14
movq 0x50(%rsp), %r13
movq 0x48(%rsp), %rbp
movq 0x40(%rsp), %r9
movq %rcx, %rdx
movq %r8, %rcx
movq %rax, %r8
callq 0x5c08
testl %eax, %eax
jne 0x6257
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x5f1e
testl %eax, %eax
je 0x6266
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x606a
| /Dragonchang[P]https_client/mbedtls/library/gcm.c |
mbedtls_gcm_self_test | int mbedtls_gcm_self_test( int verbose )
{
mbedtls_gcm_context ctx;
unsigned char buf[64];
unsigned char tag_buf[16];
int i, j, ret;
mbedtls_cipher_id_t cipher = MBEDTLS_CIPHER_ID_AES;
mbedtls_gcm_init( &ctx );
for( j = 0; j < 3; j++ )
{
int key_len = 128 + 64 * j;
for( i = 0; i < MAX_TESTS; i++ )
{
if( verbose != 0 )
mbedtls_printf( " AES-GCM-%3d #%d (%s): ",
key_len, i, "enc" );
mbedtls_gcm_setkey( &ctx, cipher, key[key_index[i]], key_len );
ret = mbedtls_gcm_crypt_and_tag( &ctx, MBEDTLS_GCM_ENCRYPT,
pt_len[i],
iv[iv_index[i]], iv_len[i],
additional[add_index[i]], add_len[i],
pt[pt_index[i]], buf, 16, tag_buf );
if( ret != 0 ||
memcmp( buf, ct[j * 6 + i], pt_len[i] ) != 0 ||
memcmp( tag_buf, tag[j * 6 + i], 16 ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
mbedtls_gcm_free( &ctx );
if( verbose != 0 )
mbedtls_printf( "passed\n" );
if( verbose != 0 )
mbedtls_printf( " AES-GCM-%3d #%d (%s): ",
key_len, i, "dec" );
mbedtls_gcm_setkey( &ctx, cipher, key[key_index[i]], key_len );
ret = mbedtls_gcm_crypt_and_tag( &ctx, MBEDTLS_GCM_DECRYPT,
pt_len[i],
iv[iv_index[i]], iv_len[i],
additional[add_index[i]], add_len[i],
ct[j * 6 + i], buf, 16, tag_buf );
if( ret != 0 ||
memcmp( buf, pt[pt_index[i]], pt_len[i] ) != 0 ||
memcmp( tag_buf, tag[j * 6 + i], 16 ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
mbedtls_gcm_free( &ctx );
if( verbose != 0 )
mbedtls_printf( "passed\n" );
if( verbose != 0 )
mbedtls_printf( " AES-GCM-%3d #%d split (%s): ",
key_len, i, "enc" );
mbedtls_gcm_setkey( &ctx, cipher, key[key_index[i]], key_len );
ret = mbedtls_gcm_starts( &ctx, MBEDTLS_GCM_ENCRYPT,
iv[iv_index[i]], iv_len[i],
additional[add_index[i]], add_len[i] );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
if( pt_len[i] > 32 )
{
size_t rest_len = pt_len[i] - 32;
ret = mbedtls_gcm_update( &ctx, 32, pt[pt_index[i]], buf );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
ret = mbedtls_gcm_update( &ctx, rest_len, pt[pt_index[i]] + 32,
buf + 32 );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
}
else
{
ret = mbedtls_gcm_update( &ctx, pt_len[i], pt[pt_index[i]], buf );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
}
ret = mbedtls_gcm_finish( &ctx, tag_buf, 16 );
if( ret != 0 ||
memcmp( buf, ct[j * 6 + i], pt_len[i] ) != 0 ||
memcmp( tag_buf, tag[j * 6 + i], 16 ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
mbedtls_gcm_free( &ctx );
if( verbose != 0 )
mbedtls_printf( "passed\n" );
if( verbose != 0 )
mbedtls_printf( " AES-GCM-%3d #%d split (%s): ",
key_len, i, "dec" );
mbedtls_gcm_setkey( &ctx, cipher, key[key_index[i]], key_len );
ret = mbedtls_gcm_starts( &ctx, MBEDTLS_GCM_DECRYPT,
iv[iv_index[i]], iv_len[i],
additional[add_index[i]], add_len[i] );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
if( pt_len[i] > 32 )
{
size_t rest_len = pt_len[i] - 32;
ret = mbedtls_gcm_update( &ctx, 32, ct[j * 6 + i], buf );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
ret = mbedtls_gcm_update( &ctx, rest_len, ct[j * 6 + i] + 32,
buf + 32 );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
}
else
{
ret = mbedtls_gcm_update( &ctx, pt_len[i], ct[j * 6 + i], buf );
if( ret != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
}
ret = mbedtls_gcm_finish( &ctx, tag_buf, 16 );
if( ret != 0 ||
memcmp( buf, pt[pt_index[i]], pt_len[i] ) != 0 ||
memcmp( tag_buf, tag[j * 6 + i], 16 ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
mbedtls_gcm_free( &ctx );
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
}
if( verbose != 0 )
mbedtls_printf( "\n" );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movl %edi, (%rsp)
leaq 0xa8(%rsp), %rdi
movl $0x1a0, %edx # imm = 0x1A0
xorl %esi, %esi
callq 0x40c0
xorl %eax, %eax
movl %eax, %r14d
shll $0x6, %r14d
subl $-0x80, %r14d
movq %rax, 0x48(%rsp)
addq %rax, %rax
leaq (%rax,%rax,2), %rax
movq %rax, 0x58(%rsp)
xorl %r12d, %r12d
movl %r14d, 0x4(%rsp)
cmpl $0x0, (%rsp)
je 0x63ab
leaq 0x736d(%rip), %rdi # 0xd704
movl %r14d, %esi
movl %r12d, %edx
leaq 0x7379(%rip), %rcx # 0xd71d
xorl %eax, %eax
callq 0x4090
leaq 0x76ae(%rip), %rax # 0xda60
movslq (%rax,%r12,4), %rbp
movq %rbp, %rbx
shlq $0x5, %rbx
leaq 0x738c(%rip), %rax # 0xd750
addq %rax, %rbx
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
movl $0x2, %esi
movq %rbx, %rdx
movl %r14d, %ecx
callq 0x5a88
leaq 0x7427(%rip), %rax # 0xd810
movq (%rax,%r12,8), %rdx
leaq 0x744c(%rip), %rax # 0xd840
movslq (%rax,%r12,4), %r14
shlq $0x6, %r14
leaq 0x781d(%rip), %rax # 0xdc20
addq %rax, %r14
leaq 0x7453(%rip), %rax # 0xd860
movq (%rax,%r12,8), %r8
leaq 0x7478(%rip), %rax # 0xd890
movslq (%rax,%r12,4), %r13
shlq $0x6, %r13
leaq 0x7979(%rip), %rax # 0xdda0
addq %rax, %r13
leaq 0x747f(%rip), %rax # 0xd8b0
movq (%rax,%r12,8), %r11
shlq $0x6, %rbp
leaq 0x74a0(%rip), %rax # 0xd8e0
movq %rbp, 0x50(%rsp)
leaq (%rax,%rbp), %r10
subq $0x8, %rsp
movq %r15, %rdi
movl $0x1, %esi
movq %rdx, 0x10(%rsp)
movq %r14, %rcx
movq %r8, 0x48(%rsp)
movq %r13, %r9
leaq 0x28(%rsp), %rax
pushq %rax
pushq $0x10
leaq 0x78(%rsp), %rax
pushq %rax
movq %r10, 0x30(%rsp)
pushq %r10
movq %r11, 0x60(%rsp)
pushq %r11
callq 0x6203
addq $0x30, %rsp
testl %eax, %eax
jne 0x6904
movq 0x58(%rsp), %rax
leaq (%r12,%rax), %rbp
movq %rbp, %r15
shlq $0x6, %r15
leaq 0x7a77(%rip), %rax # 0xdf20
addq %rax, %r15
leaq 0x60(%rsp), %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
callq 0x4170
testl %eax, %eax
jne 0x6904
shlq $0x4, %rbp
leaq 0x75af(%rip), %rax # 0xda80
movdqu (%rbp,%rax), %xmm0
pcmpeqb 0x20(%rsp), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x6904
leaq 0x758d(%rip), %rax # 0xda80
addq %rax, %rbp
movq %rbp, 0x30(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x6f28
xorl %eax, %eax
movb $0x0, 0xa8(%rsp,%rax)
incq %rax
cmpq $0x1a0, %rax # imm = 0x1A0
jne 0x650a
cmpl $0x0, (%rsp)
movl 0x4(%rsp), %ebp
je 0x654d
leaq 0x7216(%rip), %rdi # 0xd744
callq 0x4060
leaq 0x71ca(%rip), %rdi # 0xd704
movl %ebp, %esi
movl %r12d, %edx
leaq 0x71db(%rip), %rcx # 0xd721
xorl %eax, %eax
callq 0x4090
movq %r12, 0x18(%rsp)
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
movl $0x2, %esi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x5a88
subq $0x8, %rsp
movq %r12, %rdi
xorl %esi, %esi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
movq 0x48(%rsp), %r8
movq %r13, %r9
leaq 0x28(%rsp), %rax
pushq %rax
pushq $0x10
leaq 0x78(%rsp), %rax
pushq %rax
pushq %r15
pushq 0x60(%rsp)
callq 0x6203
addq $0x30, %rsp
testl %eax, %eax
movq 0x30(%rsp), %r12
jne 0x6904
leaq 0x60(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x4170
testl %eax, %eax
jne 0x6904
movdqu (%r12), %xmm0
pcmpeqb 0x20(%rsp), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x6904
leaq 0xa8(%rsp), %rdi
callq 0x6f28
xorl %eax, %eax
movb $0x0, 0xa8(%rsp,%rax)
incq %rax
cmpq $0x1a0, %rax # imm = 0x1A0
jne 0x65f5
cmpl $0x0, (%rsp)
movl 0x4(%rsp), %ebp
movq 0x18(%rsp), %r12
je 0x663d
leaq 0x7126(%rip), %rdi # 0xd744
callq 0x4060
leaq 0x70fb(%rip), %rdi # 0xd725
movl %ebp, %esi
movl %r12d, %edx
leaq 0x70e7(%rip), %rcx # 0xd71d
xorl %eax, %eax
callq 0x4090
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
movl $0x2, %esi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x5a88
movq %r12, %rdi
movl $0x1, %esi
movq %r14, %rdx
movq 0x40(%rsp), %rcx
movq %r13, %r8
movq 0x38(%rsp), %r9
callq 0x5c08
testl %eax, %eax
jne 0x6904
cmpq $0x2, 0x18(%rsp)
jb 0x66df
movl $0x20, %esi
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
movq 0x10(%rsp), %rdx
leaq 0x60(%rsp), %rcx
callq 0x5f1e
testl %eax, %eax
jne 0x6904
movq 0x8(%rsp), %rax
leaq -0x20(%rax), %rsi
leaq 0x7225(%rip), %rax # 0xd8e0
movq 0x50(%rsp), %rcx
leaq (%rcx,%rax), %rdx
addq $0x20, %rdx
movq %r12, %rdi
leaq 0x80(%rsp), %rcx
callq 0x5f1e
testl %eax, %eax
movq %r12, %rbp
jmp 0x6700
leaq 0xa8(%rsp), %rbp
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x60(%rsp), %rcx
callq 0x5f1e
testl %eax, %eax
leaq 0x20(%rsp), %rsi
jne 0x6904
movl $0x10, %edx
movq %rbp, %rdi
callq 0x606a
testl %eax, %eax
jne 0x6904
leaq 0x60(%rsp), %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
callq 0x4170
testl %eax, %eax
jne 0x6904
movq 0x30(%rsp), %rax
movdqu (%rax), %xmm0
pcmpeqb 0x20(%rsp), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x6904
movq %rbp, %rdi
callq 0x6f28
xorl %eax, %eax
movb $0x0, 0xa8(%rsp,%rax)
incq %rax
cmpq $0x1a0, %rax # imm = 0x1A0
jne 0x6762
cmpl $0x0, (%rsp)
movl 0x4(%rsp), %r12d
je 0x67a9
leaq 0x6fbd(%rip), %rdi # 0xd744
callq 0x4060
leaq 0x6f92(%rip), %rdi # 0xd725
movl %r12d, %esi
movq 0x18(%rsp), %rdx
leaq 0x6f7f(%rip), %rcx # 0xd721
xorl %eax, %eax
callq 0x4090
movq %rbp, %rdi
movl $0x2, %esi
movq %rbx, %rdx
movl %r12d, %ecx
callq 0x5a88
movq %rbp, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq 0x40(%rsp), %rcx
movq %r13, %r8
movq 0x38(%rsp), %r9
callq 0x5c08
testl %eax, %eax
jne 0x6904
movq 0x18(%rsp), %r12
cmpq $0x2, %r12
jb 0x6834
movl $0x20, %esi
movq %rbp, %rdi
movq %r15, %rdx
leaq 0x60(%rsp), %rcx
callq 0x5f1e
testl %eax, %eax
movl 0x4(%rsp), %r14d
jne 0x6904
movq 0x8(%rsp), %rax
leaq -0x20(%rax), %rsi
addq $0x20, %r15
movq %rbp, %rdi
movq %r15, %rdx
leaq 0x80(%rsp), %rcx
callq 0x5f1e
testl %eax, %eax
je 0x6856
jmp 0x6904
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %rcx
callq 0x5f1e
testl %eax, %eax
movl 0x4(%rsp), %r14d
jne 0x6904
movl $0x10, %edx
movq %rbp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x606a
testl %eax, %eax
jne 0x6904
leaq 0x60(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x4170
testl %eax, %eax
jne 0x6904
movq 0x30(%rsp), %rax
movdqu (%rax), %xmm0
pcmpeqb 0x20(%rsp), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x6904
movq %rbp, %rdi
callq 0x6f28
xorl %eax, %eax
movb $0x0, 0xa8(%rsp,%rax)
incq %rax
cmpq $0x1a0, %rax # imm = 0x1A0
jne 0x68ac
cmpl $0x0, (%rsp)
je 0x68d1
leaq 0x6e78(%rip), %rdi # 0xd744
callq 0x4060
incq %r12
cmpq $0x6, %r12
jne 0x638a
movq 0x48(%rsp), %rax
incq %rax
cmpq $0x3, %rax
jne 0x6366
xorl %ebx, %ebx
cmpl $0x0, (%rsp)
je 0x691b
movl $0xa, %edi
callq 0x4040
jmp 0x691b
movl $0x1, %ebx
cmpl $0x0, (%rsp)
je 0x691b
leaq 0xa7b7(%rip), %rdi # 0x110cd
callq 0x4060
movl %ebx, %eax
addq $0x248, %rsp # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /Dragonchang[P]https_client/mbedtls/library/gcm.c |
mbedtls_cipher_finish | int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx,
unsigned char *output, size_t *olen )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
*olen = 0;
if( MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
MBEDTLS_MODE_CTR == ctx->cipher_info->mode ||
MBEDTLS_MODE_GCM == ctx->cipher_info->mode ||
MBEDTLS_MODE_STREAM == ctx->cipher_info->mode )
{
return( 0 );
}
if( MBEDTLS_MODE_ECB == ctx->cipher_info->mode )
{
if( ctx->unprocessed_len != 0 )
return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
return( 0 );
}
#if defined(MBEDTLS_CIPHER_MODE_CBC)
if( MBEDTLS_MODE_CBC == ctx->cipher_info->mode )
{
int ret = 0;
if( MBEDTLS_ENCRYPT == ctx->operation )
{
/* check for 'no padding' mode */
if( NULL == ctx->add_padding )
{
if( 0 != ctx->unprocessed_len )
return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
return( 0 );
}
ctx->add_padding( ctx->unprocessed_data, mbedtls_cipher_get_iv_size( ctx ),
ctx->unprocessed_len );
}
else if( mbedtls_cipher_get_block_size( ctx ) != ctx->unprocessed_len )
{
/*
* For decrypt operations, expect a full block,
* or an empty block if no padding
*/
if( NULL == ctx->add_padding && 0 == ctx->unprocessed_len )
return( 0 );
return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
}
/* cipher block */
if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
ctx->operation, mbedtls_cipher_get_block_size( ctx ), ctx->iv,
ctx->unprocessed_data, output ) ) )
{
return( ret );
}
/* Set output size for decryption */
if( MBEDTLS_DECRYPT == ctx->operation )
return ctx->get_padding( output, mbedtls_cipher_get_block_size( ctx ),
olen );
/* Set output size for encryption */
*olen = mbedtls_cipher_get_block_size( ctx );
return( 0 );
}
#else
((void) output);
#endif /* MBEDTLS_CIPHER_MODE_CBC */
return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
} | pushq %r15
pushq %r14
pushq %rbx
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x7510
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testq %rbx, %rbx
sete %sil
orb %dl, %sil
jne 0x7510
movq $0x0, (%rbx)
movl 0x4(%rcx), %edx
decl %edx
cmpl $0x6, %edx
ja 0x74ac
xorl %eax, %eax
leaq 0x6f60(%rip), %rsi # 0xe3b8
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
xorl %ecx, %ecx
cmpq $0x0, 0x30(%r15)
movl $0xffff9d80, %eax # imm = 0xFFFF9D80
cmovel %ecx, %eax
jmp 0x7510
movl 0xc(%r15), %esi
cmpl $0x1, %esi
jne 0x74b3
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x7461
leaq 0x20(%r15), %rdi
movq 0x48(%r15), %rdx
testq %rdx, %rdx
jne 0x7497
movl 0x18(%rcx), %edx
movslq %edx, %rsi
movq 0x30(%r15), %rdx
callq *%rax
movq (%r15), %rcx
movl 0xc(%r15), %esi
movl 0x20(%rcx), %edx
jmp 0x74bf
movl $0xffff9f80, %eax # imm = 0xFFFF9F80
jmp 0x7510
movl 0x20(%rcx), %edx
movq 0x30(%r15), %rax
cmpq %rdx, %rax
jne 0x74ef
movq 0x28(%rcx), %rax
movq 0x50(%r15), %rdi
leaq 0x38(%r15), %rcx
leaq 0x20(%r15), %r8
movq %r14, %r9
callq *0x10(%rax)
testl %eax, %eax
jne 0x7510
cmpl $0x0, 0xc(%r15)
je 0x74fa
movq (%r15), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x750b
movl 0x20(%rcx), %ecx
jmp 0x750d
xorl %ecx, %ecx
orq 0x10(%r15), %rax
jmp 0x7468
movq (%r15), %rcx
movq 0x18(%r15), %rax
testq %rcx, %rcx
je 0x7516
movl 0x20(%rcx), %esi
jmp 0x7518
xorl %ecx, %ecx
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
xorl %esi, %esi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
| /Dragonchang[P]https_client/mbedtls/library/cipher.c |
get_one_and_zeros_padding | static int get_one_and_zeros_padding( unsigned char *input, size_t input_len,
size_t *data_len )
{
size_t i;
unsigned char done = 0, prev_done, bad;
if( NULL == input || NULL == data_len )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
bad = 0xFF;
*data_len = 0;
for( i = input_len; i > 0; i-- )
{
prev_done = done;
done |= ( input[i-1] != 0 );
*data_len |= ( i - 1 ) * ( done != prev_done );
bad &= ( input[i-1] ^ 0x80 ) | ( done == prev_done );
}
return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
} | testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
jne 0x763b
movq $0x0, (%rdx)
testq %rsi, %rsi
je 0x763c
decq %rsi
xorl %ecx, %ecx
movb $-0x1, %al
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpb $0x0, (%rdi,%rsi)
setne %r9b
orl %r8d, %r9d
cmpl %r8d, %r9d
sete %r8b
movl $0x0, %r10d
cmovneq %rsi, %r10
orq %r10, %rcx
movq %rcx, (%rdx)
orb (%rdi,%rsi), %r8b
addb $-0x80, %r8b
andb %r8b, %al
movl %r9d, %r8d
addq $-0x1, %rsi
jb 0x75f6
xorl %ecx, %ecx
testb %al, %al
movl $0xffff9e00, %eax # imm = 0xFFFF9E00
cmovel %ecx, %eax
retq
movl $0xffff9e00, %eax # imm = 0xFFFF9E00
retq
| /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_des_setkey | void mbedtls_des_setkey( uint32_t SK[32], const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
uint32_t X, Y, T;
GET_UINT32_BE( X, key, 0 );
GET_UINT32_BE( Y, key, 4 );
/*
* Permuted Choice 1
*/
T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4);
T = ((Y ) ^ X) & 0x10101010; X ^= T; Y ^= (T );
X = (LHs[ (X ) & 0xF] << 3) | (LHs[ (X >> 8) & 0xF ] << 2)
| (LHs[ (X >> 16) & 0xF] << 1) | (LHs[ (X >> 24) & 0xF ] )
| (LHs[ (X >> 5) & 0xF] << 7) | (LHs[ (X >> 13) & 0xF ] << 6)
| (LHs[ (X >> 21) & 0xF] << 5) | (LHs[ (X >> 29) & 0xF ] << 4);
Y = (RHs[ (Y >> 1) & 0xF] << 3) | (RHs[ (Y >> 9) & 0xF ] << 2)
| (RHs[ (Y >> 17) & 0xF] << 1) | (RHs[ (Y >> 25) & 0xF ] )
| (RHs[ (Y >> 4) & 0xF] << 7) | (RHs[ (Y >> 12) & 0xF ] << 6)
| (RHs[ (Y >> 20) & 0xF] << 5) | (RHs[ (Y >> 28) & 0xF ] << 4);
X &= 0x0FFFFFFF;
Y &= 0x0FFFFFFF;
/*
* calculate subkeys
*/
for( i = 0; i < 16; i++ )
{
if( i < 2 || i == 8 || i == 15 )
{
X = ((X << 1) | (X >> 27)) & 0x0FFFFFFF;
Y = ((Y << 1) | (Y >> 27)) & 0x0FFFFFFF;
}
else
{
X = ((X << 2) | (X >> 26)) & 0x0FFFFFFF;
Y = ((Y << 2) | (Y >> 26)) & 0x0FFFFFFF;
}
*SK++ = ((X << 4) & 0x24000000) | ((X << 28) & 0x10000000)
| ((X << 14) & 0x08000000) | ((X << 18) & 0x02080000)
| ((X << 6) & 0x01000000) | ((X << 9) & 0x00200000)
| ((X >> 1) & 0x00100000) | ((X << 10) & 0x00040000)
| ((X << 2) & 0x00020000) | ((X >> 10) & 0x00010000)
| ((Y >> 13) & 0x00002000) | ((Y >> 4) & 0x00001000)
| ((Y << 6) & 0x00000800) | ((Y >> 1) & 0x00000400)
| ((Y >> 14) & 0x00000200) | ((Y ) & 0x00000100)
| ((Y >> 5) & 0x00000020) | ((Y >> 10) & 0x00000010)
| ((Y >> 3) & 0x00000008) | ((Y >> 18) & 0x00000004)
| ((Y >> 26) & 0x00000002) | ((Y >> 24) & 0x00000001);
*SK++ = ((X << 15) & 0x20000000) | ((X << 17) & 0x10000000)
| ((X << 10) & 0x08000000) | ((X << 22) & 0x04000000)
| ((X >> 2) & 0x02000000) | ((X << 1) & 0x01000000)
| ((X << 16) & 0x00200000) | ((X << 11) & 0x00100000)
| ((X << 3) & 0x00080000) | ((X >> 6) & 0x00040000)
| ((X << 15) & 0x00020000) | ((X >> 4) & 0x00010000)
| ((Y >> 2) & 0x00002000) | ((Y << 8) & 0x00001000)
| ((Y >> 14) & 0x00000808) | ((Y >> 9) & 0x00000400)
| ((Y ) & 0x00000200) | ((Y << 7) & 0x00000100)
| ((Y >> 7) & 0x00000020) | ((Y >> 3) & 0x00000011)
| ((Y << 2) & 0x00000004) | ((Y >> 21) & 0x00000002);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, -0x8(%rsp)
movzbl (%rsi), %ecx
movl %ecx, %eax
shll $0x18, %eax
movzbl 0x1(%rsi), %edx
shll $0x10, %edx
orl %eax, %edx
movzbl 0x2(%rsi), %eax
shll $0x8, %eax
movzbl 0x3(%rsi), %r8d
orl %edx, %r8d
orl %eax, %r8d
movl 0x4(%rsi), %edx
bswapl %edx
movl %edx, %eax
shrl $0x4, %eax
xorl %r8d, %eax
andl $0xf0f0f0f, %eax # imm = 0xF0F0F0F
movl %eax, %esi
xorl %r8d, %esi
shll $0x4, %eax
xorl %edx, %eax
andl $0x10101010, %r8d # imm = 0x10101010
andl $0xefefefef, %eax # imm = 0xEFEFEFEF
orl %r8d, %eax
movl %esi, %edx
andl $0xf, %edx
leaq 0x69e8(%rip), %r8 # 0xe7c0
movl (%r8,%rdx,4), %edx
shll $0x3, %edx
movl %esi, %r9d
shrl $0x6, %r9d
andl $0x3c, %r9d
movl (%r9,%r8), %r9d
shll $0x2, %r9d
orl %edx, %r9d
movl %esi, %edx
shrl $0xe, %edx
andl $0x3c, %edx
movl (%rdx,%r8), %edx
addl %edx, %edx
orl %r9d, %edx
movl %esi, %r9d
shrl $0x16, %r9d
andl $0x3c, %r9d
orl (%r9,%r8), %edx
movl %esi, %r9d
shrl $0x3, %r9d
andl $0x3c, %r9d
movl (%r9,%r8), %r9d
shll $0x7, %r9d
movl %esi, %r10d
shrl $0xb, %r10d
andl $0x3c, %r10d
movl (%r10,%r8), %r10d
shll $0x6, %r10d
orl %r9d, %r10d
shrl $0x13, %esi
andl $0x3c, %esi
movl (%rsi,%r8), %esi
shll $0x5, %esi
orl %r10d, %esi
shrl $0x5, %ecx
movl (%r8,%rcx,4), %r13d
shll $0x4, %r13d
orl %esi, %r13d
movl %eax, %esi
andl $0x1e, %esi
leaq 0x6998(%rip), %rcx # 0xe800
movl (%rcx,%rsi,2), %esi
shll $0x3, %esi
movl %eax, %r8d
shrl $0x7, %r8d
andl $0x3c, %r8d
movl (%r8,%rcx), %r8d
shll $0x2, %r8d
orl %esi, %r8d
movl %eax, %esi
shrl $0xf, %esi
andl $0x3c, %esi
movl (%rsi,%rcx), %esi
addl %esi, %esi
orl %r8d, %esi
movl %eax, %r8d
shrl $0x17, %r8d
andl $0x3c, %r8d
orl (%r8,%rcx), %esi
orl %edx, %r13d
movl %eax, %edx
shrl $0x2, %edx
andl $0x3c, %edx
movl (%rdx,%rcx), %edx
shll $0x7, %edx
movl %eax, %r8d
shrl $0xa, %r8d
andl $0x3c, %r8d
movl (%r8,%rcx), %r8d
shll $0x6, %r8d
orl %edx, %r8d
movl %eax, %edx
shrl $0x12, %edx
andl $0x3c, %edx
movl (%rdx,%rcx), %edx
shll $0x5, %edx
orl %r8d, %edx
shrl $0x1c, %eax
movl (%rcx,%rax,4), %r15d
shll $0x4, %r15d
orl %edx, %r15d
orl %esi, %r15d
movl $0xfffffff, %ecx # imm = 0xFFFFFFF
andl %ecx, %r13d
andl %ecx, %r15d
xorl %r8d, %r8d
cmpl $0xf, %r8d
ja 0x81c8
movl $0x8103, %eax # imm = 0x8103
btl %r8d, %eax
jae 0x81c8
movl $0xffffffe, %r14d # imm = 0xFFFFFFE
movl $0x1b, %esi
movl $0x1, %edx
movl %r13d, %r11d
movl %edx, %ecx
shll %cl, %r11d
movl %esi, %ecx
shrl %cl, %r13d
movl %r11d, %ebx
andl %r14d, %ebx
movl %ebx, %ebp
orl %r13d, %ebp
movl %r15d, %eax
movl %edx, %ecx
shll %cl, %eax
movl %esi, %ecx
shrl %cl, %r15d
andl %eax, %r14d
movl %r14d, %r12d
orl %r15d, %r12d
movl %ebx, %ecx
shll $0x4, %ecx
andl $0x24000000, %ecx # imm = 0x24000000
andl $0x1, %r13d
shll $0x1c, %r13d
orl %ecx, %r13d
movl %r11d, %ecx
shll $0xe, %ecx
movl $0x8000000, %edx # imm = 0x8000000
andl %edx, %ecx
orl %r13d, %ecx
movl %ebp, %edx
movl %ebp, %esi
shll $0x12, %esi
andl $0x2080000, %esi # imm = 0x2080000
orl %ecx, %esi
movl %r11d, %ecx
shll $0x6, %ecx
andl $0x1000000, %ecx # imm = 0x1000000
orl %esi, %ecx
movl %r11d, %esi
shll $0x9, %esi
andl $0x200000, %esi # imm = 0x200000
orl %ecx, %esi
movl %r11d, %r13d
shrl %r13d
movl $0x100000, %ecx # imm = 0x100000
andl %ecx, %r13d
orl %esi, %r13d
shll $0xa, %edx
movl %edx, %ecx
movl $0x40000, %esi # imm = 0x40000
andl %esi, %ecx
leal (,%rbx,4), %esi
movl $0x20000, %edi # imm = 0x20000
andl %edi, %esi
orl %ecx, %esi
movl %r11d, %ecx
shrl $0xa, %ecx
movl $0x10000, %edi # imm = 0x10000
andl %edi, %ecx
orl %esi, %ecx
movl %r12d, %esi
andl $0x20, %esi
shll $0x6, %esi
movl %eax, %r9d
shrl %r9d
movl $0x400, %edi # imm = 0x400
andl %edi, %r9d
orl %esi, %r9d
shrl $0xe, %r14d
movl %r14d, %r10d
movl $0x200, %esi # imm = 0x200
andl %esi, %r10d
orl %r9d, %r10d
movl %eax, %esi
andl $0x100, %esi # imm = 0x100
orl %ecx, %esi
movl %eax, %ecx
shrl $0xd, %ecx
movl $0x2000, %edi # imm = 0x2000
andl %edi, %ecx
orl %ecx, %esi
movl %eax, %ecx
shrl $0x4, %ecx
andl $0x1000, %ecx # imm = 0x1000
orl %ecx, %esi
movl %r12d, %ecx
orl %r13d, %esi
movl %eax, %r9d
shrl $0x5, %r9d
andl $0x20, %r9d
orl %r10d, %r9d
movl %eax, %r10d
shrl $0xa, %r10d
andl $0x10, %r10d
orl %r9d, %r10d
shrl $0x3, %ecx
movl %ecx, %r9d
andl $0x8, %r9d
orl %r10d, %r9d
movl %eax, %r10d
shrl $0x12, %r10d
andl $0x4, %r10d
orl %r9d, %r10d
orl %esi, %r10d
movl %eax, %esi
shrl $0x1a, %esi
andl $0x2, %esi
movl %eax, %r9d
shrl $0x18, %r9d
andl $0x1, %r9d
orl %esi, %r9d
movl %ebp, %r13d
orl %r10d, %r9d
movq -0x8(%rsp), %rdi
movl %r9d, (%rdi,%r8,8)
shll $0xf, %r13d
movl %r13d, %esi
andl $0x20000000, %esi # imm = 0x20000000
movl %r11d, %r9d
shll $0x11, %r9d
andl $0x10000000, %r9d # imm = 0x10000000
orl %esi, %r9d
movl $0x8000000, %esi # imm = 0x8000000
andl %esi, %edx
orl %r9d, %edx
movl %ebp, %esi
andl $0x10, %esi
shll $0x16, %esi
orl %edx, %esi
movl %r11d, %edx
shrl $0x2, %edx
andl $0x2000000, %edx # imm = 0x2000000
orl %esi, %edx
movl %ebx, %esi
andl $0x800000, %esi # imm = 0x800000
leal (%rdx,%rsi,2), %esi
movl %ebp, %edx
andl $0x20, %edx
shll $0x10, %edx
orl %esi, %edx
movl %r11d, %esi
shll $0xb, %esi
movl $0x100000, %r9d # imm = 0x100000
andl %r9d, %esi
shll $0x3, %ebx
andl $0x80000, %ebx # imm = 0x80000
orl %esi, %ebx
movl %r11d, %esi
shrl $0x6, %esi
movl $0x40000, %r9d # imm = 0x40000
andl %r9d, %esi
orl %ebx, %esi
movl $0x20000, %r9d # imm = 0x20000
andl %r9d, %r13d
orl %esi, %r13d
shrl $0x4, %r11d
movl $0x10000, %esi # imm = 0x10000
andl %esi, %r11d
orl %r13d, %r11d
andl $0x808, %r14d # imm = 0x808
movl %eax, %r9d
shrl $0x9, %r9d
movl $0x400, %esi # imm = 0x400
andl %esi, %r9d
orl %r14d, %r9d
movl %eax, %esi
movl $0x200, %r10d # imm = 0x200
andl %r10d, %esi
orl %r11d, %esi
movl %eax, %r10d
shrl $0x2, %r10d
movl $0x2000, %r11d # imm = 0x2000
andl %r11d, %r10d
orl %r10d, %esi
movl %r12d, %r10d
andl $0x10, %r10d
shll $0x8, %r10d
orl %r10d, %esi
orl %edx, %esi
movl %r12d, %edx
andl $0x2, %edx
shll $0x7, %edx
orl %r9d, %edx
movl %eax, %r9d
shrl $0x7, %r9d
andl $0x20, %r9d
orl %edx, %r9d
andl $0x11, %ecx
orl %r9d, %ecx
shll $0x2, %r15d
andl $0x4, %r15d
orl %ecx, %r15d
shrl $0x15, %eax
andl $0x2, %eax
orl %r15d, %eax
orl %esi, %eax
movl %eax, 0x4(%rdi,%r8,8)
movl %r12d, %r15d
movl %ebp, %r13d
incq %r8
cmpl $0x10, %r8d
jne 0x7efa
jmp 0x81dd
movl $0xffffffc, %r14d # imm = 0xFFFFFFC
movl $0x1a, %esi
movl $0x2, %edx
jmp 0x7f23
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/des.c |
des3_set2key | static void des3_set2key( uint32_t esk[96],
uint32_t dsk[96],
const unsigned char key[MBEDTLS_DES_KEY_SIZE*2] )
{
int i;
mbedtls_des_setkey( esk, key );
mbedtls_des_setkey( dsk + 32, key + 8 );
for( i = 0; i < 32; i += 2 )
{
dsk[i ] = esk[30 - i];
dsk[i + 1] = esk[31 - i];
esk[i + 32] = dsk[62 - i];
esk[i + 33] = dsk[63 - i];
esk[i + 64] = esk[i ];
esk[i + 65] = esk[i + 1];
dsk[i + 64] = dsk[i ];
dsk[i + 65] = dsk[i + 1];
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x7d6f
leaq 0x80(%rbx), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0x7d6f
movl $0x40, %ecx
movl $0x3f, %eax
movl -0x84(%r14,%rax,4), %edx
movl %edx, -0x100(%rbx,%rcx,4)
movl -0x80(%r14,%rax,4), %edx
movl %edx, -0xfc(%rbx,%rcx,4)
movl -0x4(%rbx,%rax,4), %edx
movl %edx, -0x80(%r14,%rcx,4)
movl (%rbx,%rax,4), %edx
movl %edx, -0x7c(%r14,%rcx,4)
movq -0x100(%r14,%rcx,4), %rdx
movq %rdx, (%r14,%rcx,4)
movq -0x100(%rbx,%rcx,4), %rdx
movq %rdx, (%rbx,%rcx,4)
leaq 0x2(%rcx), %rdx
addq $-0x40, %rcx
addq $-0x2, %rax
cmpq $0x1e, %rcx
movq %rdx, %rcx
jb 0x8292
popq %rbx
popq %r14
popq %r15
retq
| /Dragonchang[P]https_client/mbedtls/library/des.c |
des3_set3key | static void des3_set3key( uint32_t esk[96],
uint32_t dsk[96],
const unsigned char key[24] )
{
int i;
mbedtls_des_setkey( esk, key );
mbedtls_des_setkey( dsk + 32, key + 8 );
mbedtls_des_setkey( esk + 64, key + 16 );
for( i = 0; i < 32; i += 2 )
{
dsk[i ] = esk[94 - i];
dsk[i + 1] = esk[95 - i];
esk[i + 32] = dsk[62 - i];
esk[i + 33] = dsk[63 - i];
dsk[i + 64] = esk[30 - i];
dsk[i + 65] = esk[31 - i];
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x7d6f
leaq 0x80(%rbx), %rdi
leaq 0x8(%r15), %rsi
callq 0x7d6f
leaq 0x100(%r14), %rdi
addq $0x10, %r15
movq %r15, %rsi
callq 0x7d6f
movq $-0x2, %rax
movl $0x3e, %ecx
movl 0x80(%r14,%rcx,4), %edx
movl %edx, 0x8(%rbx,%rax,4)
movl 0x84(%r14,%rcx,4), %edx
movl %edx, 0xc(%rbx,%rax,4)
movl (%rbx,%rcx,4), %edx
movl %edx, 0x88(%r14,%rax,4)
movl 0x4(%rbx,%rcx,4), %edx
movl %edx, 0x8c(%r14,%rax,4)
movl -0x80(%r14,%rcx,4), %edx
movl %edx, 0x108(%rbx,%rax,4)
movl -0x7c(%r14,%rcx,4), %edx
movl %edx, 0x10c(%rbx,%rax,4)
addq $0x2, %rax
addq $-0x2, %rcx
cmpq $0x1e, %rax
jb 0x8393
popq %rbx
popq %r14
popq %r15
retq
| /Dragonchang[P]https_client/mbedtls/library/des.c |
mbedtls_des_crypt_ecb | int mbedtls_des_crypt_ecb( mbedtls_des_context *ctx,
const unsigned char input[8],
unsigned char output[8] )
{
int i;
uint32_t X, Y, T, *SK;
SK = ctx->sk;
GET_UINT32_BE( X, input, 0 );
GET_UINT32_BE( Y, input, 4 );
DES_IP( X, Y );
for( i = 0; i < 8; i++ )
{
DES_ROUND( Y, X );
DES_ROUND( X, Y );
}
DES_FP( Y, X );
PUT_UINT32_BE( Y, output, 0 );
PUT_UINT32_BE( X, output, 4 );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x10(%rsp)
movq %rdi, -0x8(%rsp)
movl (%rsi), %ecx
movl 0x4(%rsi), %eax
bswapl %ecx
bswapl %eax
movl %ecx, %edx
shrl $0x4, %edx
xorl %eax, %edx
andl $0xf0f0f0f, %edx # imm = 0xF0F0F0F
xorl %edx, %eax
shll $0x4, %edx
xorl %ecx, %edx
movl %edx, %esi
shrl $0x10, %esi
movzwl %ax, %ecx
xorl %esi, %ecx
xorl %ecx, %eax
shll $0x10, %ecx
xorl %edx, %ecx
movl %eax, %edx
shrl $0x2, %edx
xorl %ecx, %edx
andl $0x33333333, %edx # imm = 0x33333333
xorl %edx, %ecx
shll $0x2, %edx
xorl %eax, %edx
movl %edx, %ebp
shrl $0x8, %ebp
xorl %ecx, %ebp
andl $0xff00ff, %ebp # imm = 0xFF00FF
xorl %ebp, %ecx
shll $0x8, %ebp
xorl %edx, %ebp
roll %ebp
movl %ebp, %eax
xorl %ecx, %eax
andl $0xaaaaaaaa, %eax # imm = 0xAAAAAAAA
xorl %eax, %ebp
xorl %ecx, %eax
roll %eax
xorl %ecx, %ecx
movl $0xfc, %r13d
movq -0x8(%rsp), %r8
leaq 0x6593(%rip), %r11 # 0xea40
leaq 0x668c(%rip), %rbx # 0xeb40
leaq 0x6785(%rip), %r14 # 0xec40
leaq 0x687e(%rip), %r15 # 0xed40
leaq 0x6977(%rip), %r12 # 0xee40
movl %ebp, %edx
movl (%r8,%rcx), %ebp
xorl %edx, %ebp
movl %edx, %edi
movl %ebp, %edx
andl $0x3f, %edx
movl %ebp, %esi
shrl $0x6, %esi
andl %r13d, %esi
leaq 0x6359(%rip), %r9 # 0xe840
xorl (%r9,%rdx,4), %eax
movl %ebp, %edx
shrl $0xe, %edx
andl %r13d, %edx
shrl $0x16, %ebp
andl %r13d, %ebp
leaq 0x6440(%rip), %r10 # 0xe940
xorl (%rsi,%r10), %eax
movl %edi, %esi
movl %edi, %r10d
roll $0x1c, %esi
xorl 0x4(%r8,%rcx), %esi
xorl (%rdx,%r11), %eax
movl %esi, %edx
andl $0x3f, %edx
xorl (%rbp,%rbx), %eax
movl %esi, %ebp
shrl $0x6, %ebp
andl %r13d, %ebp
xorl (%r14,%rdx,4), %eax
movl %esi, %edx
shrl $0xe, %edx
andl %r13d, %edx
shrl $0x16, %esi
andl %r13d, %esi
xorl (%rbp,%r15), %eax
xorl (%rdx,%r12), %eax
leaq 0x69f8(%rip), %rdi # 0xef40
xorl (%rsi,%rdi), %eax
movl 0x8(%r8,%rcx), %esi
xorl %eax, %esi
movl %esi, %edx
andl $0x3f, %edx
movl (%r9,%rdx,4), %ebp
movl %esi, %edx
shrl $0x6, %edx
andl %r13d, %edx
leaq 0x63d6(%rip), %r9 # 0xe940
xorl (%rdx,%r9), %ebp
movl %esi, %edx
shrl $0xe, %edx
andl %r13d, %edx
shrl $0x16, %esi
andl %r13d, %esi
xorl (%rdx,%r11), %ebp
movl %eax, %edx
roll $0x1c, %edx
xorl 0xc(%r8,%rcx), %edx
xorl (%rsi,%rbx), %ebp
movl %edx, %esi
andl $0x3f, %esi
xorl (%r14,%rsi,4), %ebp
movl %edx, %esi
shrl $0x6, %esi
andl %r13d, %esi
xorl (%rsi,%r15), %ebp
movl %edx, %esi
shrl $0xe, %esi
andl %r13d, %esi
xorl (%rsi,%r12), %ebp
shrl $0x16, %edx
andl %r13d, %edx
xorl (%rdx,%rdi), %ebp
xorl %r10d, %ebp
addq $0x10, %rcx
cmpl $0x80, %ecx
jne 0x84c9
rorl %ebp
movl %ebp, %ecx
xorl %eax, %ecx
andl $0xaaaaaaaa, %ecx # imm = 0xAAAAAAAA
xorl %ecx, %ebp
xorl %eax, %ecx
rorl %ecx
movl %ecx, %edx
shrl $0x8, %edx
xorl %ebp, %edx
andl $0xff00ff, %edx # imm = 0xFF00FF
xorl %edx, %ebp
shll $0x8, %edx
xorl %ecx, %edx
movl %edx, %eax
shrl $0x2, %eax
xorl %ebp, %eax
andl $0x33333333, %eax # imm = 0x33333333
xorl %eax, %ebp
shll $0x2, %eax
xorl %edx, %eax
movl %ebp, %ecx
shrl $0x10, %ecx
movzwl %ax, %edx
xorl %ecx, %edx
xorl %edx, %eax
shll $0x10, %edx
xorl %ebp, %edx
movl %edx, %ecx
shrl $0x4, %ecx
xorl %eax, %ecx
andl $0xf0f0f0f, %ecx # imm = 0xF0F0F0F
xorl %ecx, %eax
shll $0x4, %ecx
xorl %edx, %ecx
movl %ecx, %edx
shrl $0x18, %edx
movq -0x10(%rsp), %rsi
movb %dl, (%rsi)
movl %ecx, %edx
shrl $0x10, %edx
movb %dl, 0x1(%rsi)
movb %ch, 0x2(%rsi)
movb %cl, 0x3(%rsi)
movl %eax, %ecx
shrl $0x18, %ecx
movb %cl, 0x4(%rsi)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x5(%rsi)
movb %ah, 0x6(%rsi)
movb %al, 0x7(%rsi)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/des.c |
mbedtls_des3_crypt_ecb | int mbedtls_des3_crypt_ecb( mbedtls_des3_context *ctx,
const unsigned char input[8],
unsigned char output[8] )
{
int i;
uint32_t X, Y, T, *SK;
SK = ctx->sk;
GET_UINT32_BE( X, input, 0 );
GET_UINT32_BE( Y, input, 4 );
DES_IP( X, Y );
for( i = 0; i < 8; i++ )
{
DES_ROUND( Y, X );
DES_ROUND( X, Y );
}
for( i = 0; i < 8; i++ )
{
DES_ROUND( X, Y );
DES_ROUND( Y, X );
}
for( i = 0; i < 8; i++ )
{
DES_ROUND( Y, X );
DES_ROUND( X, Y );
}
DES_FP( Y, X );
PUT_UINT32_BE( Y, output, 0 );
PUT_UINT32_BE( X, output, 4 );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x8(%rsp)
movl (%rsi), %eax
movl 0x4(%rsi), %ecx
bswapl %eax
bswapl %ecx
movl %eax, %edx
shrl $0x4, %edx
xorl %ecx, %edx
andl $0xf0f0f0f, %edx # imm = 0xF0F0F0F
xorl %edx, %ecx
shll $0x4, %edx
xorl %eax, %edx
movl %edx, %esi
shrl $0x10, %esi
movzwl %cx, %eax
xorl %esi, %eax
xorl %eax, %ecx
shll $0x10, %eax
xorl %edx, %eax
movl %ecx, %edx
shrl $0x2, %edx
xorl %eax, %edx
andl $0x33333333, %edx # imm = 0x33333333
xorl %edx, %eax
shll $0x2, %edx
xorl %ecx, %edx
movl %edx, %r14d
shrl $0x8, %r14d
xorl %eax, %r14d
andl $0xff00ff, %r14d # imm = 0xFF00FF
xorl %r14d, %eax
shll $0x8, %r14d
xorl %edx, %r14d
roll %r14d
movl %r14d, %ebp
xorl %eax, %ebp
andl $0xaaaaaaaa, %ebp # imm = 0xAAAAAAAA
xorl %ebp, %r14d
xorl %eax, %ebp
roll %ebp
xorl %r15d, %r15d
movl $0xfc, %r12d
leaq 0x6393(%rip), %r8 # 0xeb40
leaq 0x658c(%rip), %r10 # 0xed40
leaq 0x6685(%rip), %rax # 0xee40
leaq 0x677e(%rip), %rcx # 0xef40
movl %r14d, %r13d
movl (%rdi,%r15), %r14d
xorl %r13d, %r14d
movq %rcx, %rsi
movl %r14d, %edx
andl $0x3f, %edx
movq %rax, %rbx
movl %r14d, %eax
shrl $0x6, %eax
andl %r12d, %eax
leaq 0x6058(%rip), %rcx # 0xe840
xorl (%rcx,%rdx,4), %ebp
movl %r14d, %edx
shrl $0xe, %edx
andl %r12d, %edx
shrl $0x16, %r14d
andl %r12d, %r14d
leaq 0x613e(%rip), %r9 # 0xe940
xorl (%rax,%r9), %ebp
movl %r13d, %eax
roll $0x1c, %eax
xorl 0x4(%rdi,%r15), %eax
movq %r8, %r9
leaq 0x6225(%rip), %r8 # 0xea40
xorl (%rdx,%r8), %ebp
movl %eax, %edx
andl $0x3f, %edx
xorl (%r14,%r9), %ebp
movl %eax, %r14d
shrl $0x6, %r14d
andl %r12d, %r14d
movq %r10, %r11
leaq 0x6404(%rip), %r10 # 0xec40
xorl (%r10,%rdx,4), %ebp
movl %eax, %edx
shrl $0xe, %edx
andl %r12d, %edx
shrl $0x16, %eax
andl %r12d, %eax
xorl (%r14,%r11), %ebp
xorl (%rdx,%rbx), %ebp
xorl (%rax,%rsi), %ebp
movl 0x8(%rdi,%r15), %eax
xorl %ebp, %eax
movl %eax, %edx
andl $0x3f, %edx
movl (%rcx,%rdx,4), %r14d
leaq 0x60d1(%rip), %rcx # 0xe940
movl %eax, %edx
shrl $0x6, %edx
andl %r12d, %edx
xorl (%rdx,%rcx), %r14d
movl %eax, %edx
shrl $0xe, %edx
andl %r12d, %edx
shrl $0x16, %eax
andl %r12d, %eax
xorl (%rdx,%r8), %r14d
movq %r9, %r8
movl %ebp, %edx
roll $0x1c, %edx
xorl 0xc(%rdi,%r15), %edx
xorl (%rax,%r9), %r14d
movl %edx, %eax
andl $0x3f, %eax
xorl (%r10,%rax,4), %r14d
movq %r11, %r10
movl %edx, %eax
shrl $0x6, %eax
andl %r12d, %eax
xorl (%rax,%r11), %r14d
movl %edx, %eax
shrl $0xe, %eax
andl %r12d, %eax
xorl (%rax,%rbx), %r14d
movq %rbx, %rax
shrl $0x16, %edx
andl %r12d, %edx
xorl (%rdx,%rsi), %r14d
movq %rsi, %rcx
xorl %r13d, %r14d
addq $0x10, %r15
cmpl $0x80, %r15d
jne 0x87c2
xorl %r15d, %r15d
movl $0xfc, %r12d
leaq 0x634a(%rip), %r10 # 0xec40
movl %ebp, %r13d
movl 0x80(%rdi,%r15), %ebp
xorl %r13d, %ebp
movl %ebp, %edx
andl $0x3f, %edx
movl %ebp, %eax
shrl $0x6, %eax
andl %r12d, %eax
leaq 0x5f28(%rip), %rcx # 0xe840
xorl (%rcx,%rdx,4), %r14d
movl %ebp, %edx
shrl $0xe, %edx
andl %r12d, %edx
shrl $0x16, %ebp
andl %r12d, %ebp
leaq 0x600f(%rip), %r8 # 0xe940
xorl (%rax,%r8), %r14d
movl %r13d, %eax
roll $0x1c, %eax
xorl 0x84(%rdi,%r15), %eax
leaq 0x60f6(%rip), %r8 # 0xea40
xorl (%rdx,%r8), %r14d
movl %eax, %edx
andl $0x3f, %edx
xorl (%rbp,%r9), %r14d
movl %eax, %ebp
shrl $0x6, %ebp
andl %r12d, %ebp
xorl (%r10,%rdx,4), %r14d
movl %eax, %edx
shrl $0xe, %edx
andl %r12d, %edx
shrl $0x16, %eax
andl %r12d, %eax
xorl (%rbp,%r11), %r14d
xorl (%rdx,%rbx), %r14d
xorl (%rax,%rsi), %r14d
movl 0x88(%rdi,%r15), %eax
xorl %r14d, %eax
movl %eax, %edx
andl $0x3f, %edx
movl (%rcx,%rdx,4), %ebp
movl %eax, %edx
shrl $0x6, %edx
andl %r12d, %edx
leaq 0x5f9f(%rip), %rcx # 0xe940
xorl (%rdx,%rcx), %ebp
movl %eax, %edx
shrl $0xe, %edx
andl %r12d, %edx
shrl $0x16, %eax
andl %r12d, %eax
xorl (%rdx,%r8), %ebp
movl %r14d, %edx
roll $0x1c, %edx
xorl 0x8c(%rdi,%r15), %edx
xorl (%rax,%r9), %ebp
movl %edx, %eax
andl $0x3f, %eax
xorl (%r10,%rax,4), %ebp
movl %edx, %eax
shrl $0x6, %eax
andl %r12d, %eax
xorl (%rax,%r11), %ebp
movl %edx, %eax
shrl $0xe, %eax
andl %r12d, %eax
xorl (%rax,%rbx), %ebp
shrl $0x16, %edx
andl %r12d, %edx
xorl (%rdx,%rsi), %ebp
xorl %r13d, %ebp
addq $0x10, %r15
cmpl $0x80, %r15d
jne 0x88f6
xorl %r15d, %r15d
movl $0xfc, %r12d
leaq 0x622b(%rip), %r10 # 0xec40
movl %r14d, %r13d
movl 0x100(%rdi,%r15), %r14d
xorl %r13d, %r14d
movl %r14d, %edx
andl $0x3f, %edx
movl %r14d, %eax
shrl $0x6, %eax
andl %r12d, %eax
leaq 0x5e07(%rip), %rcx # 0xe840
xorl (%rcx,%rdx,4), %ebp
movl %r14d, %edx
shrl $0xe, %edx
andl %r12d, %edx
shrl $0x16, %r14d
andl %r12d, %r14d
leaq 0x5eed(%rip), %r8 # 0xe940
xorl (%rax,%r8), %ebp
movl %r13d, %eax
roll $0x1c, %eax
xorl 0x104(%rdi,%r15), %eax
leaq 0x5fd4(%rip), %r8 # 0xea40
xorl (%rdx,%r8), %ebp
movl %eax, %edx
andl $0x3f, %edx
xorl (%r14,%r9), %ebp
movl %eax, %r14d
shrl $0x6, %r14d
andl %r12d, %r14d
xorl (%r10,%rdx,4), %ebp
movl %eax, %edx
shrl $0xe, %edx
andl %r12d, %edx
shrl $0x16, %eax
andl %r12d, %eax
xorl (%r14,%r11), %ebp
xorl (%rdx,%rbx), %ebp
xorl (%rax,%rsi), %ebp
movl 0x108(%rdi,%r15), %eax
xorl %ebp, %eax
movl %eax, %edx
andl $0x3f, %edx
movl (%rcx,%rdx,4), %r14d
movl %eax, %edx
shrl $0x6, %edx
andl %r12d, %edx
leaq 0x5e7f(%rip), %rcx # 0xe940
xorl (%rdx,%rcx), %r14d
movl %eax, %edx
shrl $0xe, %edx
andl %r12d, %edx
shrl $0x16, %eax
andl %r12d, %eax
xorl (%rdx,%r8), %r14d
movl %ebp, %edx
roll $0x1c, %edx
xorl 0x10c(%rdi,%r15), %edx
xorl (%rax,%r9), %r14d
movl %edx, %eax
andl $0x3f, %eax
xorl (%r10,%rax,4), %r14d
movl %edx, %eax
shrl $0x6, %eax
andl %r12d, %eax
xorl (%rax,%r11), %r14d
movl %edx, %eax
shrl $0xe, %eax
andl %r12d, %eax
xorl (%rax,%rbx), %r14d
shrl $0x16, %edx
andl %r12d, %edx
xorl (%rdx,%rsi), %r14d
xorl %r13d, %r14d
addq $0x10, %r15
cmpl $0x80, %r15d
jne 0x8a15
rorl %r14d
movl %r14d, %eax
xorl %ebp, %eax
andl $0xaaaaaaaa, %eax # imm = 0xAAAAAAAA
xorl %eax, %r14d
xorl %ebp, %eax
rorl %eax
movl %eax, %ecx
shrl $0x8, %ecx
xorl %r14d, %ecx
andl $0xff00ff, %ecx # imm = 0xFF00FF
xorl %ecx, %r14d
shll $0x8, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
xorl %r14d, %eax
andl $0x33333333, %eax # imm = 0x33333333
xorl %eax, %r14d
shll $0x2, %eax
xorl %ecx, %eax
movl %r14d, %ecx
shrl $0x10, %ecx
movzwl %ax, %edx
xorl %ecx, %edx
xorl %edx, %eax
shll $0x10, %edx
xorl %r14d, %edx
movl %edx, %ecx
shrl $0x4, %ecx
xorl %eax, %ecx
andl $0xf0f0f0f, %ecx # imm = 0xF0F0F0F
xorl %ecx, %eax
shll $0x4, %ecx
xorl %edx, %ecx
movl %ecx, %edx
shrl $0x18, %edx
movq -0x8(%rsp), %rsi
movb %dl, (%rsi)
movl %ecx, %edx
shrl $0x10, %edx
movb %dl, 0x1(%rsi)
movb %ch, 0x2(%rsi)
movb %cl, 0x3(%rsi)
movl %eax, %ecx
shrl $0x18, %ecx
movb %cl, 0x4(%rsi)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x5(%rsi)
movb %ah, 0x6(%rsi)
movb %al, 0x7(%rsi)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/des.c |
mbedtls_aes_setkey_enc | int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits )
{
unsigned int i;
uint32_t *RK;
#if !defined(MBEDTLS_AES_ROM_TABLES)
if( aes_init_done == 0 )
{
aes_gen_tables();
aes_init_done = 1;
}
#endif
switch( keybits )
{
case 128: ctx->nr = 10; break;
case 192: ctx->nr = 12; break;
case 256: ctx->nr = 14; break;
default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
}
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
if( aes_padlock_ace == -1 )
aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
if( aes_padlock_ace )
ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
else
#endif
ctx->rk = RK = ctx->buf;
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
return( mbedtls_aesni_setkey_enc( (unsigned char *) ctx->rk, key, keybits ) );
#endif
for( i = 0; i < ( keybits >> 5 ); i++ )
{
GET_UINT32_LE( RK[i], key, i << 2 );
}
switch( ctx->nr )
{
case 10:
for( i = 0; i < 10; i++, RK += 4 )
{
RK[4] = RK[0] ^ RCON[i] ^
( (uint32_t) FSb[ ( RK[3] >> 8 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( RK[3] ) & 0xFF ] << 24 );
RK[5] = RK[1] ^ RK[4];
RK[6] = RK[2] ^ RK[5];
RK[7] = RK[3] ^ RK[6];
}
break;
case 12:
for( i = 0; i < 8; i++, RK += 6 )
{
RK[6] = RK[0] ^ RCON[i] ^
( (uint32_t) FSb[ ( RK[5] >> 8 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( RK[5] ) & 0xFF ] << 24 );
RK[7] = RK[1] ^ RK[6];
RK[8] = RK[2] ^ RK[7];
RK[9] = RK[3] ^ RK[8];
RK[10] = RK[4] ^ RK[9];
RK[11] = RK[5] ^ RK[10];
}
break;
case 14:
for( i = 0; i < 7; i++, RK += 8 )
{
RK[8] = RK[0] ^ RCON[i] ^
( (uint32_t) FSb[ ( RK[7] >> 8 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( RK[7] ) & 0xFF ] << 24 );
RK[9] = RK[1] ^ RK[8];
RK[10] = RK[2] ^ RK[9];
RK[11] = RK[3] ^ RK[10];
RK[12] = RK[4] ^
( (uint32_t) FSb[ ( RK[11] ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( RK[11] >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 );
RK[13] = RK[5] ^ RK[12];
RK[14] = RK[6] ^ RK[13];
RK[15] = RK[7] ^ RK[14];
}
break;
}
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp # imm = 0x818
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0xd038(%rip) # 0x161e0
jne 0x94f4
movl $0x1, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movl %edx, 0x410(%rsp,%rcx,4)
movl %edx, %esi
movl %ecx, 0x10(%rsp,%rsi,4)
leal (%rdx,%rdx), %esi
cmpl $0x80, %edx
movl $0x1b, %edi
cmovbl %eax, %edi
movzbl %sil, %esi
xorl %edx, %esi
xorl %edi, %esi
incq %rcx
movl %esi, %edx
cmpq $0x100, %rcx # imm = 0x100
jne 0x91b7
movl $0x1, %edx
xorl %eax, %eax
leaq 0xcff7(%rip), %rcx # 0x161f0
xorl %esi, %esi
movl %edx, (%rsi,%rcx)
leal (%rdx,%rdx), %edi
cmpl $0x80, %edx
movl $0x1b, %r8d
cmovbl %eax, %r8d
movzbl %dil, %edx
xorl %r8d, %edx
addq $0x4, %rsi
cmpq $0x28, %rsi
jne 0x91fb
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movb $0x63, 0xcfee(%rip) # 0x16220
movb $0x0, 0xf14a(%rip) # 0x18383
movl $0x1, %edx
movl $0xff, %esi
leaq 0xcfd6(%rip), %rax # 0x16220
leaq 0xf0cf(%rip), %rcx # 0x18320
movslq 0x10(%rsp,%rdx,4), %rdi
movl $0xff, %r8d
subq %rdi, %r8
movl 0x410(%rsp,%r8,4), %r9d
leal (%r9,%r9), %edi
movl %r9d, %r8d
shrl $0x7, %r8d
orl %edi, %r8d
movl %r8d, %edi
andl %esi, %edi
addl %r8d, %r8d
movl %edi, %r10d
shrl $0x7, %r10d
andl %esi, %r8d
orl %r8d, %r10d
leal (%r10,%r10), %r11d
shrl $0x7, %r8d
andl %esi, %r11d
orl %r11d, %r8d
shrl $0x7, %r11d
xorl %r9d, %edi
xorl %r10d, %edi
xorl %r8d, %edi
andl $0x7f, %r8d
leal (%r11,%r8,2), %r8d
xorl %r8d, %edi
movslq %edi, %rdi
xorq $0x63, %rdi
movb %dil, (%rdx,%rax)
movb %dl, (%rdi,%rcx)
incq %rdx
cmpq $0x100, %rdx # imm = 0x100
jne 0x9251
movl 0x48(%rsp), %edx
movl 0x34(%rsp), %esi
movl 0x3c(%rsp), %edi
movl 0x44(%rsp), %r8d
movq $-0x400, %r9 # imm = 0xFC00
leaq 0xdc37(%rip), %r11 # 0x16f20
xorl %r12d, %r12d
movzbl (%r12,%rax), %r13d
leal (,%r13,2), %ebp
testb %r13b, %r13b
movl $0x1b, %r14d
movl $0x0, %r10d
cmovnsl %r10d, %r14d
movzbl %bpl, %ebp
xorl %r14d, %ebp
movl %ebp, %r14d
xorl %r13d, %r14d
movl %r13d, %r15d
shll $0x8, %r15d
shll $0x10, %r13d
orl %r15d, %r13d
shll $0x18, %r14d
orl %r13d, %r14d
orl %ebp, %r14d
movl %r14d, %ebp
roll $0x8, %ebp
leaq 0xdfe2(%rip), %r10 # 0x17320
movl %r14d, 0x400(%r9,%r10)
movl %r14d, %r15d
roll $0x10, %r15d
leaq 0xe3cc(%rip), %r10 # 0x17720
movl %ebp, 0x400(%r9,%r10)
leaq 0xe7bd(%rip), %r10 # 0x17b20
movl %r15d, 0x400(%r9,%r10)
roll $0x18, %r14d
leaq 0xebaa(%rip), %r10 # 0x17f20
movl %r14d, 0x400(%r9,%r10)
movzbl (%r12,%rcx), %ebp
movl $0x0, %r13d
testq %rbp, %rbp
je 0x9490
movl 0x10(%rsp,%rbp,4), %r13d
leal (%rdx,%r13), %ebp
movslq %ebp, %r14
imulq $-0x7f7f7f7f, %r14, %r15 # imm = 0x80808081
shrq $0x20, %r15
addl %r14d, %r15d
movl %r15d, %ebp
shrl $0x1f, %ebp
sarl $0x7, %r15d
addl %ebp, %r15d
movl %r15d, %ebp
shll $0x8, %ebp
subl %ebp, %r15d
addl %r14d, %r15d
movslq %r15d, %r14
leal (%rsi,%r13), %ebp
movslq %ebp, %r15
imulq $-0x7f7f7f7f, %r15, %rbp # imm = 0x80808081
shrq $0x20, %rbp
addl %r15d, %ebp
movl %ebp, %r10d
shrl $0x1f, %r10d
sarl $0x7, %ebp
addl %r10d, %ebp
movl %ebp, %r10d
shll $0x8, %r10d
subl %r10d, %ebp
addl %r15d, %ebp
movslq %ebp, %r10
movl 0x410(%rsp,%r10,4), %ebp
shll $0x8, %ebp
xorl 0x410(%rsp,%r14,4), %ebp
leal (%r8,%r13), %r10d
movslq %r10d, %r10
imulq $-0x7f7f7f7f, %r10, %r14 # imm = 0x80808081
shrq $0x20, %r14
addl %r10d, %r14d
movl %r14d, %r15d
shrl $0x1f, %r15d
sarl $0x7, %r14d
addl %r15d, %r14d
movl %r14d, %r15d
shll $0x8, %r15d
subl %r15d, %r14d
addl %r10d, %r14d
movslq %r14d, %r10
movl 0x410(%rsp,%r10,4), %r10d
shll $0x10, %r10d
addl %edi, %r13d
movslq %r13d, %r14
imulq $-0x7f7f7f7f, %r14, %r15 # imm = 0x80808081
shrq $0x20, %r15
addl %r14d, %r15d
movl %r15d, %r13d
shrl $0x1f, %r13d
sarl $0x7, %r15d
addl %r13d, %r15d
movl %r15d, %r13d
shll $0x8, %r13d
subl %r13d, %r15d
addl %r14d, %r15d
movslq %r15d, %r14
movl 0x410(%rsp,%r14,4), %r13d
shll $0x18, %r13d
xorl %r10d, %r13d
xorl %ebp, %r13d
leaq 0xce89(%rip), %r10 # 0x16320
movl %r13d, 0x400(%r9,%r10)
movl %r13d, %r10d
roll $0x8, %r10d
leaq 0xd273(%rip), %r14 # 0x16720
movl %r10d, 0x400(%r9,%r14)
movl %r13d, %r10d
roll $0x10, %r10d
roll $0x18, %r13d
leaq 0xd659(%rip), %r14 # 0x16b20
movl %r10d, 0x400(%r9,%r14)
movl %r13d, 0x400(%r9,%r11)
incq %r12
addq $0x4, %r9
jne 0x92ec
movb $0x1, 0xccf5(%rip) # 0x161e0
movq 0x8(%rsp), %r14
movq (%rsp), %r15
cmpl $0x80, %r15d
je 0x9526
cmpl $0x100, %r15d # imm = 0x100
je 0x951f
movl $0xffffffe0, %eax # imm = 0xFFFFFFE0
cmpl $0xc0, %r15d
jne 0x9803
movl $0xc, %eax
jmp 0x952b
movl $0xe, %eax
jmp 0x952b
movl $0xa, %eax
movl %eax, (%rbx)
leaq 0x10(%rbx), %rax
movq %rax, 0x8(%rbx)
movl $0x2000000, %edi # imm = 0x2000000
callq 0x6930
testl %eax, %eax
je 0x9563
movq 0x8(%rbx), %rdi
movl %r15d, %edx
movq %r14, %rsi
addq $0x818, %rsp # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6bb0
shrl $0x5, %r15d
xorl %eax, %eax
movl (%r14,%rax,4), %ecx
movl %ecx, 0x10(%rbx,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0x9569
movl (%rbx), %ecx
cmpl $0xa, %ecx
je 0x9762
cmpl $0xc, %ecx
je 0x96ac
xorl %eax, %eax
cmpl $0xe, %ecx
jne 0x9803
movl 0x10(%rbx), %r8d
xorl %eax, %eax
leaq 0xcc4b(%rip), %rcx # 0x161f0
movl $0xff, %edx
leaq 0xcc6f(%rip), %rsi # 0x16220
xorl %edi, %edi
xorl (%rdi,%rcx), %r8d
movl 0x2c(%rbx,%rdi,8), %r9d
movl %r9d, %r10d
shrl $0x8, %r10d
andl %edx, %r10d
movzbl (%r10,%rsi), %r10d
xorl %r8d, %r10d
movl %r9d, %r8d
shrl $0x10, %r8d
andl %edx, %r8d
movzbl (%r8,%rsi), %r11d
shll $0x8, %r11d
xorl %r10d, %r11d
movl %r9d, %r8d
shrl $0x18, %r8d
movzbl (%r8,%rsi), %r10d
shll $0x10, %r10d
movzbl %r9b, %r8d
movzbl (%r8,%rsi), %r8d
shll $0x18, %r8d
xorl %r10d, %r8d
xorl %r11d, %r8d
movl %r8d, 0x30(%rbx,%rdi,8)
movl 0x14(%rbx,%rdi,8), %r10d
xorl %r8d, %r10d
movl %r10d, 0x34(%rbx,%rdi,8)
xorl 0x18(%rbx,%rdi,8), %r10d
movl %r10d, 0x38(%rbx,%rdi,8)
xorl 0x1c(%rbx,%rdi,8), %r10d
movl %r10d, 0x3c(%rbx,%rdi,8)
movl %r10d, %r11d
andl %edx, %r11d
movzbl (%r11,%rsi), %r11d
xorl 0x20(%rbx,%rdi,8), %r11d
movl %r10d, %r14d
shrl $0x8, %r14d
andl %edx, %r14d
movzbl (%r14,%rsi), %ebp
shll $0x8, %ebp
xorl %r11d, %ebp
movl %r10d, %r11d
shrl $0x10, %r11d
andl %edx, %r11d
movzbl (%r11,%rsi), %r11d
shll $0x10, %r11d
shrl $0x18, %r10d
movzbl (%r10,%rsi), %r10d
shll $0x18, %r10d
xorl %r11d, %r10d
xorl %ebp, %r10d
movl %r10d, 0x40(%rbx,%rdi,8)
xorl 0x24(%rbx,%rdi,8), %r10d
movl %r10d, 0x44(%rbx,%rdi,8)
xorl 0x28(%rbx,%rdi,8), %r10d
movl %r10d, 0x48(%rbx,%rdi,8)
xorl %r9d, %r10d
movl %r10d, 0x4c(%rbx,%rdi,8)
addq $0x4, %rdi
cmpq $0x1c, %rdi
jne 0x95b3
jmp 0x9803
movl 0x10(%rbx), %r8d
addq $0x3c, %rbx
xorl %eax, %eax
leaq 0xcb33(%rip), %rcx # 0x161f0
movl $0xff, %edx
leaq 0xcb57(%rip), %rsi # 0x16220
xorl %edi, %edi
xorl (%rdi,%rcx), %r8d
movl -0x18(%rbx), %r9d
movl %r9d, %r10d
shrl $0x8, %r10d
andl %edx, %r10d
movzbl (%r10,%rsi), %r10d
xorl %r8d, %r10d
movl %r9d, %r8d
shrl $0x10, %r8d
andl %edx, %r8d
movzbl (%r8,%rsi), %r11d
shll $0x8, %r11d
xorl %r10d, %r11d
movl %r9d, %r8d
shrl $0x18, %r8d
movzbl (%r8,%rsi), %r10d
shll $0x10, %r10d
movzbl %r9b, %r8d
movzbl (%r8,%rsi), %r8d
shll $0x18, %r8d
xorl %r10d, %r8d
xorl %r11d, %r8d
movl %r8d, -0x14(%rbx)
movl -0x28(%rbx), %r10d
xorl %r8d, %r10d
movl %r10d, -0x10(%rbx)
xorl -0x24(%rbx), %r10d
movl %r10d, -0xc(%rbx)
xorl -0x20(%rbx), %r10d
movl %r10d, -0x8(%rbx)
xorl -0x1c(%rbx), %r10d
movl %r10d, -0x4(%rbx)
xorl %r9d, %r10d
movl %r10d, (%rbx)
addq $0x4, %rdi
addq $0x18, %rbx
cmpq $0x20, %rdi
jne 0x96cb
jmp 0x9803
movl 0x10(%rbx), %r8d
xorl %eax, %eax
leaq 0xca81(%rip), %rcx # 0x161f0
movl $0xff, %edx
leaq 0xcaa5(%rip), %rsi # 0x16220
xorl %edi, %edi
xorl (%rdi,%rcx), %r8d
movl 0x1c(%rbx,%rdi,4), %r9d
movl %r9d, %r10d
shrl $0x8, %r10d
andl %edx, %r10d
movzbl (%r10,%rsi), %r10d
xorl %r8d, %r10d
movl %r9d, %r8d
shrl $0x10, %r8d
andl %edx, %r8d
movzbl (%r8,%rsi), %r11d
shll $0x8, %r11d
xorl %r10d, %r11d
movl %r9d, %r8d
shrl $0x18, %r8d
movzbl (%r8,%rsi), %r10d
shll $0x10, %r10d
movzbl %r9b, %r8d
movzbl (%r8,%rsi), %r8d
shll $0x18, %r8d
xorl %r10d, %r8d
xorl %r11d, %r8d
movl %r8d, 0x20(%rbx,%rdi,4)
movl 0x14(%rbx,%rdi,4), %r10d
xorl %r8d, %r10d
movl %r10d, 0x24(%rbx,%rdi,4)
xorl 0x18(%rbx,%rdi,4), %r10d
movl %r10d, 0x28(%rbx,%rdi,4)
xorl %r9d, %r10d
movl %r10d, 0x2c(%rbx,%rdi,4)
addq $0x4, %rdi
cmpq $0x28, %rdi
jne 0x977d
addq $0x818, %rsp # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aes_setkey_dec | int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits )
{
int i, j, ret;
mbedtls_aes_context cty;
uint32_t *RK;
uint32_t *SK;
mbedtls_aes_init( &cty );
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
if( aes_padlock_ace == -1 )
aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
if( aes_padlock_ace )
ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
else
#endif
ctx->rk = RK = ctx->buf;
/* Also checks keybits */
if( ( ret = mbedtls_aes_setkey_enc( &cty, key, keybits ) ) != 0 )
goto exit;
ctx->nr = cty.nr;
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
{
mbedtls_aesni_inverse_key( (unsigned char *) ctx->rk,
(const unsigned char *) cty.rk, ctx->nr );
goto exit;
}
#endif
SK = cty.rk + cty.nr * 4;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
{
for( j = 0; j < 4; j++, SK++ )
{
*RK++ = RT0[ FSb[ ( *SK ) & 0xFF ] ] ^
RT1[ FSb[ ( *SK >> 8 ) & 0xFF ] ] ^
RT2[ FSb[ ( *SK >> 16 ) & 0xFF ] ] ^
RT3[ FSb[ ( *SK >> 24 ) & 0xFF ] ];
}
}
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
exit:
mbedtls_aes_free( &cty );
return( ret );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movl $0x120, %edx # imm = 0x120
movq %r12, %rdi
xorl %esi, %esi
callq 0x40c0
leaq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x9187
movl %eax, %ebx
testl %eax, %eax
jne 0x9995
movl 0x8(%rsp), %eax
movl %eax, (%r14)
movl $0x2000000, %edi # imm = 0x2000000
callq 0x6930
testl %eax, %eax
je 0x988c
movq 0x8(%r14), %rdi
movq 0x10(%rsp), %rsi
movl (%r14), %edx
callq 0x6b79
jmp 0x9995
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
movl 0x10(%rax), %ecx
movl %ecx, 0x10(%r14)
movl 0x14(%rax), %ecx
movl %ecx, 0x14(%r14)
movl 0x18(%rax), %ecx
movl %ecx, 0x18(%r14)
movl 0x1c(%rax), %ecx
leaq 0x20(%r14), %r15
movl %ecx, 0x1c(%r14)
movl (%r14), %ecx
cmpl $0x2, %ecx
jl 0x997b
leaq 0xc94c(%rip), %rdx # 0x16220
leaq 0xca45(%rip), %rsi # 0x16320
movl $0xff, %edi
leaq 0xce39(%rip), %r8 # 0x16720
leaq 0xd232(%rip), %r9 # 0x16b20
leaq 0xd62b(%rip), %r11 # 0x16f20
movq %r15, %r10
xorl %r15d, %r15d
xorl %r14d, %r14d
movl (%rax,%r15,4), %r12d
movzbl %r12b, %r13d
movzbl (%r13,%rdx), %r13d
movl %r12d, %ebp
shrl $0x8, %ebp
andl %edi, %ebp
movzbl (%rbp,%rdx), %ebp
movl (%r8,%rbp,4), %ebp
xorl (%rsi,%r13,4), %ebp
movl %r12d, %r13d
shrl $0x10, %r13d
andl %edi, %r13d
movzbl (%r13,%rdx), %r13d
xorl (%r9,%r13,4), %ebp
shrl $0x18, %r12d
movzbl (%r12,%rdx), %r12d
xorl (%r11,%r12,4), %ebp
movl %ebp, (%r10,%r15,4)
addq $-0x4, %r14
incq %r15
cmpl $0x4, %r15d
jne 0x98fe
leal -0x1(%rcx), %ebp
movq %rax, %r12
subq %r14, %r12
leaq -0x20(%r12), %rax
movq %r10, %r15
subq %r14, %r15
cmpl $0x2, %ecx
movl %ebp, %ecx
jg 0x98f5
addq $-0x20, %r12
subq %r14, %r10
movq %r10, %r15
movq %r12, %rax
movl (%rax), %ecx
movl %ecx, (%r15)
movl 0x4(%rax), %ecx
movl %ecx, 0x4(%r15)
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r15)
movl 0xc(%rax), %eax
movl %eax, 0xc(%r15)
xorl %eax, %eax
movb $0x0, 0x8(%rsp,%rax)
incq %rax
cmpq $0x120, %rax # imm = 0x120
jne 0x9997
movl %ebx, %eax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aes_crypt_cbc | int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[16];
if( length % 16 )
return( MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
if( aes_padlock_ace )
{
if( mbedtls_padlock_xcryptcbc( ctx, mode, length, iv, input, output ) == 0 )
return( 0 );
// If padlock data misaligned, we just fall back to
// unaccelerated mode
//
}
#endif
if( mode == MBEDTLS_AES_DECRYPT )
{
while( length > 0 )
{
memcpy( temp, input, 16 );
mbedtls_aes_crypt_ecb( ctx, mode, input, output );
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
memcpy( iv, temp, 16 );
input += 16;
output += 16;
length -= 16;
}
}
else
{
while( length > 0 )
{
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
mbedtls_aes_crypt_ecb( ctx, mode, output, output );
memcpy( iv, output, 16 );
input += 16;
output += 16;
length -= 16;
}
}
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl $0xffffffde, %eax # imm = 0xFFFFFFDE
testb $0xf, %r12b
jne 0xa3e8
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %esi, %ebp
movq %rdi, %r13
testl %esi, %esi
je 0xa3a1
testq %r12, %r12
je 0xa3e6
xorl %eax, %eax
movb (%r15,%rax), %cl
xorb (%r14,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
cmpq $0x10, %rax
jne 0xa366
movq %r13, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %rbx, %rcx
callq 0xa2cb
movups (%rbx), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addq $-0x10, %r12
jne 0xa364
jmp 0xa3e6
testq %r12, %r12
je 0xa3e6
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xa2cb
xorl %eax, %eax
movb (%r15,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
cmpq $0x10, %rax
jne 0xa3c0
movaps (%rsp), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addq $-0x10, %r12
jne 0xa3a6
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aes_crypt_cfb128 | int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
int mode,
size_t length,
size_t *iv_off,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
int c;
size_t n = *iv_off;
if( mode == MBEDTLS_AES_DECRYPT )
{
while( length-- )
{
if( n == 0 )
mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
c = *input++;
*output++ = (unsigned char)( c ^ iv[n] );
iv[n] = (unsigned char) c;
n = ( n + 1 ) & 0x0F;
}
}
else
{
while( length-- )
{
if( n == 0 )
mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
n = ( n + 1 ) & 0x0F;
}
}
*iv_off = n;
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rdx, %r12
movq %rdi, 0x8(%rsp)
movq 0x50(%rsp), %rbx
movq %rcx, 0x10(%rsp)
movq (%rcx), %rbp
testl %esi, %esi
je 0xa465
testq %r12, %r12
je 0xa4a6
xorl %r13d, %r13d
testq %rbp, %rbp
jne 0xa446
movq 0x8(%rsp), %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %r15, %rcx
callq 0xa2cb
movb (%r14,%r13), %al
xorb (%r15,%rbp), %al
movb %al, (%rbx,%r13)
movb %al, (%r15,%rbp)
incl %ebp
andl $0xf, %ebp
incq %r13
cmpq %r13, %r12
jne 0xa42c
jmp 0xa4a6
testq %r12, %r12
je 0xa4a6
xorl %r13d, %r13d
testq %rbp, %rbp
jne 0xa487
movq 0x8(%rsp), %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %r15, %rcx
callq 0xa2cb
movb (%r14,%r13), %al
movb (%r15,%rbp), %cl
xorb %al, %cl
movb %cl, (%rbx,%r13)
movb %al, (%r15,%rbp)
incl %ebp
andl $0xf, %ebp
incq %r13
cmpq %r13, %r12
jne 0xa46d
movq 0x10(%rsp), %rax
movq %rbp, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_arc4_setup | void mbedtls_arc4_setup( mbedtls_arc4_context *ctx, const unsigned char *key,
unsigned int keylen )
{
int i, j, a;
unsigned int k;
unsigned char *m;
ctx->x = 0;
ctx->y = 0;
m = ctx->m;
for( i = 0; i < 256; i++ )
m[i] = (unsigned char) i;
j = k = 0;
for( i = 0; i < 256; i++, k++ )
{
if( k >= keylen ) k = 0;
a = m[i];
j = ( j + a + key[k] ) & 0xFF;
m[i] = m[j];
m[j] = (unsigned char) a;
}
} | movq $0x0, (%rdi)
movdqa 0x445e(%rip), %xmm0 # 0xf120
xorl %eax, %eax
movdqa 0x4874(%rip), %xmm1 # 0xf540
movdqu %xmm0, 0x8(%rdi,%rax)
addq $0x10, %rax
paddb %xmm1, %xmm0
cmpq $0x100, %rax # imm = 0x100
jne 0xaccc
pushq %rbx
xorl %eax, %eax
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpl %edx, %r8d
cmovael %eax, %r8d
movb 0x8(%rdi,%rcx), %r10b
addb %r10b, %r9b
addb (%rsi,%r8), %r9b
movzbl %r9b, %r11d
movb 0x8(%rdi,%r11), %bl
movb %bl, 0x8(%rdi,%rcx)
movb %r10b, 0x8(%rdi,%r11)
incq %rcx
incl %r8d
cmpq $0x100, %rcx # imm = 0x100
jne 0xaced
popq %rbx
retq
| /Dragonchang[P]https_client/mbedtls/library/arc4.c |
mbedtls_blowfish_setkey | int mbedtls_blowfish_setkey( mbedtls_blowfish_context *ctx, const unsigned char *key,
unsigned int keybits )
{
unsigned int i, j, k;
uint32_t data, datal, datar;
if( keybits < MBEDTLS_BLOWFISH_MIN_KEY_BITS || keybits > MBEDTLS_BLOWFISH_MAX_KEY_BITS ||
( keybits % 8 ) )
{
return( MBEDTLS_ERR_BLOWFISH_INVALID_KEY_LENGTH );
}
keybits >>= 3;
for( i = 0; i < 4; i++ )
{
for( j = 0; j < 256; j++ )
ctx->S[i][j] = S[i][j];
}
j = 0;
for( i = 0; i < MBEDTLS_BLOWFISH_ROUNDS + 2; ++i )
{
data = 0x00000000;
for( k = 0; k < 4; ++k )
{
data = ( data << 8 ) | key[j++];
if( j >= keybits )
j = 0;
}
ctx->P[i] = P[i] ^ data;
}
datal = 0x00000000;
datar = 0x00000000;
for( i = 0; i < MBEDTLS_BLOWFISH_ROUNDS + 2; i += 2 )
{
blowfish_enc( ctx, &datal, &datar );
ctx->P[i] = datal;
ctx->P[i + 1] = datar;
}
for( i = 0; i < 4; i++ )
{
for( j = 0; j < 256; j += 2 )
{
blowfish_enc( ctx, &datal, &datar );
ctx->S[i][j] = datal;
ctx->S[i][j + 1] = datar;
}
}
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
leal -0x20(%r14), %eax
cmpl $0x1a1, %eax # imm = 0x1A1
setae %cl
testb $0x7, %r14b
setne %dl
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
orb %cl, %dl
jne 0xafdf
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x46f3(%rip), %r13 # 0xf5d0
leaq (%rbx,%r12), %rdi
addq $0x48, %rdi
leaq (%r12,%r13), %rsi
movl $0x400, %edx # imm = 0x400
callq 0x4140
addq $0x400, %r12 # imm = 0x400
cmpq $0x1000, %r12 # imm = 0x1000
jne 0xaedd
shrl $0x3, %r14d
xorl %eax, %eax
leaq 0x56c0(%rip), %rcx # 0x105d0
xorl %edx, %edx
xorl %esi, %esi
movl $0x4, %edi
xorl %r8d, %r8d
movl %r8d, %r9d
shll $0x8, %r9d
movl %esi, %r8d
incl %esi
movzbl (%r15,%r8), %r8d
orl %r9d, %r8d
cmpl %r14d, %esi
cmovael %eax, %esi
decl %edi
jne 0xaf1c
xorl (%rcx,%rdx,4), %r8d
movl %r8d, (%rbx,%rdx,4)
incq %rdx
cmpq $0x12, %rdx
jne 0xaf14
xorl %eax, %eax
leaq 0x4(%rsp), %r14
movl %eax, (%r14)
movq %rsp, %r15
movl %eax, (%r15)
movq $-0x2, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xafee
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rbx,%r12,4)
movl (%rsp), %eax
movl %eax, 0xc(%rbx,%r12,4)
addq $0x2, %r12
cmpq $0x10, %r12
jb 0xaf62
leaq 0x4c(%rbx), %r12
xorl %r13d, %r13d
leaq 0x4(%rsp), %r14
movq %rsp, %r15
movq $-0x2, %rbp
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xafee
movl 0x4(%rsp), %eax
movl %eax, 0x4(%r12,%rbp,4)
movl (%rsp), %eax
movl %eax, 0x8(%r12,%rbp,4)
addq $0x2, %rbp
cmpq $0xfe, %rbp
jb 0xafa1
incq %r13
addq $0x400, %r12 # imm = 0x400
cmpq $0x4, %r13
jne 0xaf9a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/blowfish.c |
blowfish_enc | static void blowfish_enc( mbedtls_blowfish_context *ctx, uint32_t *xl, uint32_t *xr )
{
uint32_t Xl, Xr, temp;
short i;
Xl = *xl;
Xr = *xr;
for( i = 0; i < MBEDTLS_BLOWFISH_ROUNDS; ++i )
{
Xl = Xl ^ ctx->P[i];
Xr = F( ctx, Xl ) ^ Xr;
temp = Xl;
Xl = Xr;
Xr = temp;
}
temp = Xl;
Xl = Xr;
Xr = temp;
Xr = Xr ^ ctx->P[MBEDTLS_BLOWFISH_ROUNDS];
Xl = Xl ^ ctx->P[MBEDTLS_BLOWFISH_ROUNDS + 1];
*xl = Xl;
*xr = Xr;
} | pushq %rbx
movl (%rsi), %r9d
movl (%rdx), %eax
xorl %ecx, %ecx
movl $0xff, %r8d
movl %eax, %r10d
movl %r9d, %eax
xorl (%rdi,%rcx,4), %eax
movl %eax, %r11d
movl %eax, %ebx
shrl $0x18, %ebx
movl %eax, %r9d
shrl $0xe, %r9d
andl $0x3fc, %r9d # imm = 0x3FC
movl 0x448(%rdi,%r9), %r9d
addl 0x48(%rdi,%rbx,4), %r9d
andl %r8d, %r11d
movl %eax, %ebx
shrl $0x8, %ebx
andl %r8d, %ebx
xorl 0x848(%rdi,%rbx,4), %r9d
addl 0xc48(%rdi,%r11,4), %r9d
xorl %r10d, %r9d
incq %rcx
cmpq $0x10, %rcx
jne 0xaffc
xorl 0x40(%rdi), %r9d
xorl 0x44(%rdi), %eax
movl %eax, (%rsi)
movl %r9d, (%rdx)
popq %rbx
retq
| /Dragonchang[P]https_client/mbedtls/library/blowfish.c |
ftmgr_fill | void ftmgr_fill(struct ftmgr *ftmgr)
{
if(ftmgr->fd == -1)
return;
while(ftmgr->bitmap) {
int rn;
uint8_t seq;
seq = ffs(ftmgr->bitmap) - 1;
rn =read(ftmgr->fd, ftmgr->ftq[seq].blk + BLK_HDR_SIZE, BLK_MTU - BLK_HDR_SIZE);
if(rn <= 0) {
close(ftmgr->fd);
ftmgr->fd = -1;
break;
}
ftmgr->bitmap &= ~(1 << seq);
U32_TO_STREAM(ftmgr->ftq[seq].blk, ftmgr->offset);
ftmgr->offset += rn;
ftmgr->ftq[seq].size = rn + BLK_HDR_SIZE;
ftmgr->ftq[seq].tts = ftmgr->tts++;
}
} | cmpl $-0x1, (%rdi)
je 0x2401
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x38(%rdi), %r12
movb 0x5(%rbx), %al
testb %al, %al
je 0x23f8
movzbl %al, %eax
bsfl %eax, %r15d
movl (%rbx), %edi
leaq (%r15,%r15,2), %r13
movq 0x8(%r12,%r13,8), %rsi
addq $0x4, %rsi
movl $0x1f7, %edx # imm = 0x1F7
callq 0x2120
movq %rax, %r14
testl %r14d, %r14d
jle 0x23e6
movb $-0x2, %al
movl %r15d, %ecx
rolb %cl, %al
andb %al, 0x5(%rbx)
leaq (%r12,%r13,8), %rax
movl 0x8(%rbx), %ecx
movq 0x8(%rax), %rdx
movl %ecx, (%rdx)
addl %r14d, 0x8(%rbx)
movl %r14d, %ecx
addl $0x4, %ecx
movw %cx, 0x10(%rax)
movb 0x4(%rbx), %cl
leal 0x1(%rcx), %edx
movb %dl, 0x4(%rbx)
movb %cl, (%rax)
jmp 0x23f3
movl (%rbx), %edi
callq 0x2110
movl $0xffffffff, (%rbx) # imm = 0xFFFFFFFF
testl %r14d, %r14d
jg 0x2385
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /LuoZhongYao[P]muxt/src/ftmgr.c |
fm_write | int fm_write(struct chmgr *chmgr, uint8_t fn, const void *payload, uint16_t len)
{
uint16_t crc;
uint8_t *fm = (uint8_t*)malloc(FM_HDR_SIZE + len + 2);
fm[0] = fn;
U16_TO_STREAM(fm + 1, len);
memcpy(fm + 3, payload, len);
crc = calc_crc(fm, FM_HDR_SIZE + len);
U16_TO_STREAM(fm + FM_HDR_SIZE + len, crc);
slip_encode(chmgr->slip, fm, FM_HDR_SIZE + len + 2);
return len;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, (%rsp)
leal 0x3(%rbx), %r15d
leal 0x5(%rbx), %r14d
movq %r14, %rdi
callq 0x2160
movq %rax, %rbp
movb %r13b, (%rax)
movb %bl, 0x1(%rax)
movb %bh, 0x2(%rax)
leaq 0x3(%rax), %rdi
movl %ebx, %r13d
movq %r12, %rsi
movq %r13, %rdx
callq 0x2150
movl $0xffff, %r12d # imm = 0xFFFF
andl %r12d, %r15d
movq %rbp, %rdi
movl %r15d, %esi
callq 0x2d2a
movw %ax, 0x3(%rbp,%r13)
movq (%rsp), %rax
movq 0x10(%rax), %rdi
andl %r12d, %r14d
movq %rbp, %rsi
movl %r14d, %edx
callq 0x27a1
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /LuoZhongYao[P]muxt/src/channel.c |
SuffixTree::GeneralizedSuffixTree::BuildSuffixTreeFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void GeneralizedSuffixTree::BuildSuffixTreeFromFile (std::string filename)
{
// load strings from file
printf ("Loading strings...\n");
FILE *file = fopen (filename.c_str(), "r");
if (!file)
throw std::string ("Can not open file: ") + filename;
char strbuf[1024];
uint symbols_num = 0;
while (fgets (strbuf, 1024, file))
{
uint len = strlen (strbuf);
if (len > 0)
{
strbuf[len - 1] = '\0';
strings.push_back (strbuf);
symbols_num += len;
}
}
fclose (file);
printf ("\r\rStrings were loaded successfully\n");
// allocate space for nodes and leaves
if (symbols_num)
{
nodes = static_cast<char *> (malloc (symbols_num * sizeof (Node)));
leaves = static_cast<char *> (malloc (symbols_num * sizeof (Leaf)));
}
else
{
nodes = static_cast<char *> (malloc (sizeof (Node)));
leaves = static_cast<char *> (malloc (sizeof (Leaf)));
}
// build tree
root = AllocNode (nullptr, nullptr);
root->suffix_link = root;
active_node = root;
active_edge = 0;
active_length = 0;
remainder = 0;
for (uint i = 0; i < strings.size(); ++i)
{
printf ("\rBuilding tree: %.2f %%", i * 100.0f / strings.size());
for (uint j = 0; j <= strings[i].size(); ++j)
{
char symbol = strings[i][j];
uint letter = MakeLetter (symbol, i);
Node *last_inserted_node = nullptr;
++remainder;
while (remainder)
{
// try add symbol
Node *old_active_node = active_node;
if (AddSymbol (symbol))
{
if (last_inserted_node)
last_inserted_node->suffix_link = old_active_node;
break;
}
// insert node or leaf
if (active_length)
{
// insert node
Node *node = InsertNode (letter, i, j);
if (last_inserted_node)
last_inserted_node->suffix_link = node;
last_inserted_node = node;
}
else
{
// insert leaf
InsertLeaf (letter, i, j);
if (last_inserted_node)
last_inserted_node->suffix_link = active_node;
last_inserted_node = active_node;
}
// move to next active point
if (active_node != root)
{
active_node = active_node->suffix_link;
if (active_length)
Move (i, j - active_length);
}
else if (active_length)
{
--active_length;
Move (i, j - active_length);
}
--remainder;
}
}
}
printf ("\rTree was built successfully\n");
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp # imm = 0x448
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2c91(%rip), %rdi # 0x73d8
callq 0x4220
movq (%r15), %rdi
leaq 0x2956(%rip), %rsi # 0x70ac
callq 0x4180
testq %rax, %rax
je 0x4a9f
movq %rax, %r12
leaq -0x470(%rbp), %rdi
movl $0x400, %esi # imm = 0x400
movq %rax, %rdx
callq 0x4230
testq %rax, %rax
je 0x481c
movl $0x0, -0x30(%rbp)
leaq -0x470(%rbp), %r15
movq %r15, %rdi
callq 0x4090
movq %rax, %r13
testl %r13d, %r13d
je 0x4801
movl %r13d, %eax
decl %eax
movb $0x0, -0x470(%rbp,%rax)
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %r15, %rdi
callq 0x4090
leaq (%rax,%rbp), %rdx
addq $-0x470, %rdx # imm = 0xFB90
leaq -0x68(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x4656
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b08
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x47fd
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x4160
addl %r13d, -0x30(%rbp)
movq %r15, %rdi
movl $0x400, %esi # imm = 0x400
movq %r12, %rdx
callq 0x4230
testq %rax, %rax
jne 0x4792
jmp 0x4823
movl $0x0, -0x30(%rbp)
movq %r12, %rdi
callq 0x4140
leaq 0x2bb9(%rip), %rdi # 0x73eb
callq 0x4220
movl -0x30(%rbp), %eax
testl %eax, %eax
je 0x485e
movl %eax, %r14d
movq %r14, %rax
shlq $0x5, %rax
leaq (%rax,%rax,2), %rdi
callq 0x41e0
movq %rax, 0x48(%rbx)
shlq $0x4, %r14
movq %r14, %rdi
jmp 0x4871
movl $0x60, %edi
callq 0x41e0
movq %rax, 0x48(%rbx)
movl $0x10, %edi
callq 0x41e0
movq %rax, 0x50(%rbx)
movq 0x48(%rbx), %rax
movl 0x58(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x58(%rbx)
leaq (%rcx,%rcx,2), %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdx
xorps %xmm0, %xmm0
addq %rcx, %rax
addq $0x58, %rax
movups %xmm0, -0x58(%rax)
movq %rdx, -0x48(%rax)
movq %rdx, -0x40(%rax)
xorl %r14d, %r14d
movq %r14, -0x38(%rax)
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq %rdx, 0x60(%rbx)
movq %rdx, -0x50(%rax)
movq %rdx, 0x68(%rbx)
movq %r14, 0x70(%rbx)
movl $0x0, 0x78(%rbx)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
je 0x4a81
sarq $0x5, %rax
xorl %r15d, %r15d
movl %r14d, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
mulss 0x279f(%rip), %xmm0 # 0x70a8
testq %rax, %rax
js 0x4918
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
jmp 0x4930
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x2783(%rip), %rdi # 0x70c2
movb $0x1, %al
callq 0x4030
shlq $0x5, %r15
movq (%rbx), %rax
movq %r15, -0x70(%rbp)
addq %r15, %rax
movq %r14, -0x40(%rbp)
movl %r14d, %ecx
shll $0x8, %ecx
movl %ecx, -0x44(%rbp)
xorl %esi, %esi
movq (%rax), %rax
movq %rsi, -0x30(%rbp)
movsbl (%rax,%rsi), %r13d
testl %r13d, %r13d
movl %r13d, %eax
cmovel -0x44(%rbp), %eax
movl %eax, -0x34(%rbp)
incl 0x78(%rbx)
xorl %r14d, %r14d
cmpl $0x0, 0x78(%rbx)
je 0x4a47
movq 0x68(%rbx), %r12
movsbl %r13b, %esi
movq %rbx, %rdi
callq 0x4bbc
movl %eax, %r15d
testb %al, %al
je 0x49b5
testq %r14, %r14
je 0x4a3e
movq %r12, 0x8(%r14)
jmp 0x4a3e
cmpl $0x0, 0x74(%rbx)
je 0x49dc
movq %rbx, %rdi
movl -0x34(%rbp), %esi
movq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x4c38
testq %r14, %r14
je 0x49d7
movq %rax, 0x8(%r14)
movq %rax, %r14
jmp 0x4a00
movq %rbx, %rdi
movl -0x34(%rbp), %esi
movq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x4de6
testq %r14, %r14
je 0x49fc
movq 0x68(%rbx), %rax
movq %rax, 0x8(%r14)
movq 0x68(%rbx), %r14
movq 0x68(%rbx), %rax
cmpq 0x60(%rbx), %rax
je 0x4a1b
movq 0x8(%rax), %rax
movq %rax, 0x68(%rbx)
movl 0x74(%rbx), %eax
testl %eax, %eax
jne 0x4a27
jmp 0x4a3b
movl 0x74(%rbx), %eax
testl %eax, %eax
je 0x4a3b
decl %eax
movl %eax, 0x74(%rbx)
movq -0x30(%rbp), %rcx
movl %ecx, %edx
subl %eax, %edx
movq %rbx, %rdi
movq -0x40(%rbp), %rsi
callq 0x4ea2
decl 0x78(%rbx)
testb %r15b, %r15b
je 0x4982
movq -0x30(%rbp), %rsi
incl %esi
movq (%rbx), %rcx
movq -0x70(%rbp), %rdx
leaq (%rcx,%rdx), %rax
cmpq %rsi, 0x8(%rcx,%rdx)
jae 0x4963
movq 0x8(%rbx), %rax
subq (%rbx), %rax
movq -0x40(%rbp), %r14
incl %r14d
sarq $0x5, %rax
movq %r14, %r15
cmpq %r14, %rax
ja 0x48f6
leaq 0x2986(%rip), %rdi # 0x740e
callq 0x4220
addq $0x448, %rsp # imm = 0x448
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x40a0
movq %rax, %rbx
leaq -0x460(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x25f0(%rip), %rsi # 0x70ae
leaq 0x25fc(%rip), %rdx # 0x70c1
leaq -0x470(%rbp), %rdi
callq 0x4656
movb $0x1, %r12b
leaq -0x470(%rbp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x593a
xorl %r12d, %r12d
leaq 0x52b8(%rip), %rsi # 0x9da8
movq 0x54d9(%rip), %rdx # 0x9fd0
movq %rbx, %rdi
callq 0x4260
movq %rax, %r14
movq -0x470(%rbp), %rdi
cmpq %r13, %rdi
je 0x4b25
movq -0x460(%rbp), %rsi
incq %rsi
callq 0x4160
jmp 0x4b25
movq %rax, %r14
movb $0x1, %r12b
testb %r12b, %r12b
je 0x4b55
movq %rbx, %rdi
callq 0x40f0
jmp 0x4b55
movq %rax, %r14
jmp 0x4b55
movq %rax, %r14
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4b55
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x4160
movq %r14, %rdi
callq 0x4270
nop
| /kachkov98[P]suffixtree/suffixtree.cpp |
SuffixTree::GeneralizedSuffixTree::InsertNode(unsigned int, unsigned int, unsigned int) | Node *GeneralizedSuffixTree::InsertNode (uint letter, uint string, uint pos)
{
// can not insert node if active point is not on edge
assert (active_length);
// create node
Node *node = AllocNode (active_node, root);
Edge &edge = active_node->edges[active_edge];
// old branch
uint old_pos = edge.start + active_length;
if (edge.length)
{
node->edges.emplace (MakeLetter (strings[edge.string_number][old_pos], edge.string_number),
Edge (edge.node, edge.string_number, old_pos, edge.length - active_length));
edge.node->parent = node;
}
else
{
node->edges.emplace (MakeLetter (strings[edge.string_number][old_pos], edge.string_number),
Edge (edge.leaf, edge.string_number, old_pos));
edge.leaf->parent = node;
}
// new leaf
node->edges.emplace (letter, Edge (AllocLeaf (node, string), string, pos));
// setup parent
edge.node = node;
edge.length = active_length;
return node;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, -0x2c(%rbp)
movl %esi, -0x34(%rbp)
cmpl $0x0, 0x74(%rdi)
je 0x4dc7
movl %edx, %r15d
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movq 0x60(%rdi), %rcx
movq 0x48(%rdi), %rdx
movl 0x58(%rdi), %esi
leal 0x1(%rsi), %edi
movl %edi, 0x58(%rbx)
leaq (%rsi,%rsi,2), %rsi
shlq $0x5, %rsi
leaq (%rdx,%rsi), %r12
leaq (%rdx,%rsi), %r13
addq $0x28, %r13
movq %rax, -0x28(%r13)
movq %rcx, -0x20(%r13)
movq %r12, -0x18(%r13)
movq %r12, -0x10(%r13)
movq $0x0, -0x8(%r13)
leaq 0x58(%rdx,%rsi), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq 0x68(%rbx), %rdi
addq $0x28, %rdi
leaq 0x70(%rbx), %rsi
callq 0x6224
movq %rax, %r14
movl 0x74(%rbx), %ecx
movl 0xc(%rax), %eax
addl %ecx, %eax
cmpl $0x0, 0x10(%r14)
je 0x4d2c
movl 0x8(%r14), %edx
movq (%rbx), %rsi
movq %rdx, %rdi
shlq $0x5, %rdi
movq (%rsi,%rdi), %rsi
movsbl (%rsi,%rax), %esi
shll $0x8, %edx
testl %esi, %esi
cmovnel %esi, %edx
leaq -0x30(%rbp), %rsi
movl %edx, (%rsi)
movq (%r14), %rdi
movl 0x8(%r14), %r8d
movl 0x10(%r14), %r9d
subl %ecx, %r9d
leaq -0x50(%rbp), %rdx
movq %rdi, (%rdx)
movl %r8d, 0x8(%rdx)
movl %eax, 0xc(%rdx)
movl %r9d, 0x10(%rdx)
jmp 0x4d6b
movl 0x8(%r14), %ecx
movq (%rbx), %rdx
movq %rcx, %rsi
shlq $0x5, %rsi
movq (%rdx,%rsi), %rdx
movsbl (%rdx,%rax), %edx
shll $0x8, %ecx
testl %edx, %edx
cmovnel %edx, %ecx
leaq -0x30(%rbp), %rsi
movl %ecx, (%rsi)
movq (%r14), %rcx
movl 0x8(%r14), %edi
leaq -0x50(%rbp), %rdx
movq %rcx, (%rdx)
movl %edi, 0x8(%rdx)
movl %eax, 0xc(%rdx)
movl $0x0, 0x10(%rdx)
movq %r13, %rdi
callq 0x6636
movq (%r14), %rax
movq %r12, (%rax)
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x5834
leaq -0x50(%rbp), %rdx
movq %rax, (%rdx)
movl %r15d, 0x8(%rdx)
movl -0x2c(%rbp), %eax
movl %eax, 0xc(%rdx)
movl $0x0, 0x10(%rdx)
leaq -0x34(%rbp), %rsi
movq %r13, %rdi
callq 0x655a
movq %r12, (%r14)
movl 0x74(%rbx), %eax
movl %eax, 0x10(%r14)
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24a7(%rip), %rdi # 0x7275
leaq 0x238f(%rip), %rsi # 0x7164
leaq 0x2510(%rip), %rcx # 0x72ec
movl $0x123, %edx # imm = 0x123
callq 0x40d0
| /kachkov98[P]suffixtree/suffixtree.cpp |
SuffixTree::GeneralizedSuffixTree::CalculateNumLeavesNumLCA(SuffixTree::Node*) | void GeneralizedSuffixTree::CalculateNumLeavesNumLCA (Node *node)
{
for (const auto &edge_pair : node->edges)
if (edge_pair.second.length)
{
CalculateNumLeavesNumLCA (edge_pair.second.node);
node->num_leaves += edge_pair.second.node->num_leaves;
node->num_lca += edge_pair.second.node->num_lca;
}
else
++node->num_leaves;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x38(%rsi), %r15
testq %r15, %r15
je 0x5713
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x20(%r15)
je 0x5708
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x56c6
movq 0x10(%r15), %rax
movl 0x20(%rax), %eax
addl %eax, 0x20(%rbx)
movq 0x10(%r15), %rax
movl 0x24(%rax), %eax
addl %eax, 0x24(%rbx)
jmp 0x570b
incl 0x20(%rbx)
movq (%r15), %r15
testq %r15, %r15
jne 0x56df
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /kachkov98[P]suffixtree/suffixtree.cpp |
SuffixTree::GeneralizedSuffixTree::FindAnswers(SuffixTree::Node*, unsigned int) | void GeneralizedSuffixTree::FindAnswers (Node *node, uint cur_substring_length)
{
for (const auto &edge_pair : node->edges)
if (edge_pair.second.length)
FindAnswers (edge_pair.second.node, cur_substring_length + edge_pair.second.length);
uint num_substrings = node->num_leaves - node->num_lca;
if (num_substrings > 1 && cur_substring_length > answers[num_substrings - 1].second)
answers[num_substrings - 1] = std::pair<Node *, uint> (node, cur_substring_length);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x38(%rsi), %r12
testq %r12, %r12
je 0x5758
movl 0x20(%r12), %edx
testl %edx, %edx
je 0x5752
movq 0x10(%r12), %rsi
addl %ebx, %edx
movq %r15, %rdi
callq 0x571e
movq (%r12), %r12
jmp 0x5735
movl 0x20(%r14), %eax
subl 0x24(%r14), %eax
cmpl $0x1, %eax
jbe 0x577e
decl %eax
movq 0x30(%r15), %rcx
shlq $0x4, %rax
cmpl %ebx, 0x8(%rcx,%rax)
jae 0x577e
addq %rax, %rcx
movq %r14, (%rcx)
movl %ebx, 0x8(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /kachkov98[P]suffixtree/suffixtree.cpp |
ReadStream::ReadStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | ReadStream::ReadStream(std::string filePath) {
f.open(filePath, std::ios::binary);
f.seekg (0, std::ios::end);
size = f.tellg() * 16;
f.seekg (0, std::ios::beg);
if(!f.is_open())
cout << "Shortcut or Jump List file is not opened. "
<< "Please check that you input correct path and start program again." << endl;
else
fileIsOpen = true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2210
movb $0x0, 0x208(%rbx)
movl $0x0, 0x20c(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x21a0
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2270
movq %rbx, %rdi
callq 0x2340
shll $0x4, %eax
movl %eax, 0x20c(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2270
leaq 0x78(%rbx), %rdi
callq 0x2050
testb %al, %al
je 0xb326
movb $0x1, 0x208(%rbx)
jmp 0xb384
movq 0xb4ca3(%rip), %rdi # 0xbffd0
leaq 0x59cf1(%rip), %rsi # 0x65025
movl $0x2a, %edx
callq 0x2220
movq 0xb4c8b(%rip), %r14 # 0xbffd0
leaq 0x59d04(%rip), %rsi # 0x65050
movl $0x41, %edx
movq %r14, %rdi
callq 0x2220
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0xb4c59(%rip), %rdi # 0xbffd0
callq 0x2030
movq %rax, %rdi
callq 0x2140
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xb38e
movq %rax, %r14
movq %rbx, %rdi
callq 0x2060
movq %r14, %rdi
callq 0x2350
nop
| /aasmirnova7[P]lnk_parser/source/utils/ReadStream.cpp |
Utils::print_vec_from_to(std::vector<unsigned int, std::allocator<unsigned int>>, int, int) | void Utils::print_vec_from_to(std::vector<unsigned int> vec, int from, int to) {
int count = 0;
for (int i = from; i < to; ++i) {
if(count >= 25) {
std::cout << endl << " ";
count = 0;
}
std::cout << hex << vec[i] << ' ';
++count;
}
std::cout << endl;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
subl %esi, %ebx
jle 0x12cc0
movq %rdi, %r14
movslq %esi, %rbp
xorl %r12d, %r12d
movq 0xad3a1(%rip), %r15 # 0xbffd0
leaq 0x7(%rsp), %r13
cmpl $0x19, %r12d
jl 0x12c78
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movl $0x24, %edx
movq %rax, %rdi
leaq 0x5432e(%rip), %rsi # 0x66f9e
callq 0x2220
xorl %r12d, %r12d
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq (%r14), %rax
movl (%rax,%rbp,4), %esi
movq %r15, %rdi
callq 0x2130
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
incl %r12d
incq %rbp
decl %ebx
jne 0x12c34
movq 0xad309(%rip), %rbx # 0xbffd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /aasmirnova7[P]lnk_parser/source/utils/Utils.cpp |
Utils::fillItemIdList(int, __gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>) | std::vector<LinkTargetIDList::ItemIDList> Utils::fillItemIdList(int count, std::vector<unsigned char>::const_iterator it) {
std::vector<LinkTargetIDList::ItemIDList> IDList;
while (count > 0) {
LinkTargetIDList::ItemIDList itemIdList;
copy(it, it + 2, std::back_inserter(itemIdList.ItemIDSize)); // 2 byte
it = it + 2;
reverse(itemIdList.ItemIDSize.begin(), itemIdList.ItemIDSize.end());
int itemIDSize = Utils::lenTwoBytes(itemIdList.ItemIDSize);
copy(it, it + itemIDSize - 2, std::back_inserter(itemIdList.Data)); // itemIDSize byte
reverse(itemIdList.Data.begin(), itemIdList.Data.end());
it = it + itemIDSize - 2;
IDList.push_back(itemIdList);
count = count - itemIDSize;
}
return IDList;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %esi, %esi
jle 0x13070
movq %rdx, %r13
movl %esi, %ebp
movq %rsp, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
leaq 0x2(%r13), %r14
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1402c
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
setne %dl
addq $-0x4, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x12fa7
addq $0x4, %rax
movl -0x4(%rax), %edx
movl (%rcx), %esi
movl %esi, -0x4(%rax)
movl %edx, (%rcx)
addq $-0x4, %rcx
leaq 0x4(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x12f8d
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0xfe80
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl (%rdi), %r12d
shll $0x8, %r12d
orl 0x4(%rdi), %r12d
movslq %r12d, %r13
subq %rdi, %rsi
callq 0x21e0
addq %r14, %r13
addq $-0x2, %r13
movq %r14, %rdi
movq %r13, %rsi
leaq 0x18(%rsp), %rdx
callq 0x1402c
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq %rcx, %rax
setne %dl
addq $-0x4, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x1302d
addq $0x4, %rax
movl -0x4(%rax), %edx
movl (%rcx), %esi
movl %esi, -0x4(%rax)
movl %edx, (%rcx)
addq $-0x4, %rcx
leaq 0x4(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x13013
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12706
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1304f
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x21e0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x13065
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21e0
subl %r12d, %ebp
testl %ebp, %ebp
jg 0x12f43
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13086
jmp 0x13086
movq %rax, %r14
movq %rsp, %rdi
callq 0x12730
movq %rbx, %rdi
callq 0x11688
movq %r14, %rdi
callq 0x2350
nop
| /aasmirnova7[P]lnk_parser/source/utils/Utils.cpp |
Utils::vectEightBytesToUnsignedInt(std::vector<unsigned int, std::allocator<unsigned int>>, int) | long long int Utils::vectEightBytesToUnsignedInt(std::vector<unsigned int> vec, int pos) {
unsigned int result = (vec[pos+0] << 8) | vec[pos+1];
unsigned int result2 = (vec[pos+2] << 8) | vec[pos+3];
long long int result3 = (result << 16) | result2;
unsigned int result4 = (vec[pos+4] << 8) | vec[pos+5];
unsigned int result5 = (vec[pos+6] << 8) | vec[pos+7];
long long int result6 = (result4 << 16) | result5;
long long int result7 = (result3 << 32) | result6;
return result7;
} | movslq %esi, %rcx
movq (%rdi), %rdx
movl (%rdx,%rcx,4), %esi
movl 0x4(%rdx,%rcx,4), %eax
movl 0x8(%rdx,%rcx,4), %edi
shll $0x8, %edi
shll $0x18, %esi
shll $0x10, %eax
orl %esi, %eax
orl 0xc(%rdx,%rcx,4), %eax
orl %edi, %eax
movl 0x10(%rdx,%rcx,4), %esi
movl 0x14(%rdx,%rcx,4), %edi
movl 0x18(%rdx,%rcx,4), %r8d
shll $0x8, %r8d
shll $0x18, %esi
shll $0x10, %edi
orl %esi, %edi
orl 0x1c(%rdx,%rcx,4), %edi
orl %r8d, %edi
shlq $0x20, %rax
orq %rdi, %rax
retq
| /aasmirnova7[P]lnk_parser/source/utils/Utils.cpp |
Utils::getDateFromPos(std::vector<unsigned int, std::allocator<unsigned int>>, int) | void Utils::getDateFromPos(std::vector<unsigned int> vec, int pos) {
long long int time_l = vectEightBytesToUnsignedInt(vec, pos);
time_t rawtime = convertWindowsTimeToUnixTime(time_l);
struct tm * timeinfo;
timeinfo = localtime(&rawtime);
cout << asctime(timeinfo);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xfe80
movq %r14, %rdi
movl %ebx, %esi
callq 0x130a2
movq %rax, %rbx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1318d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21e0
movabsq $-0x29406b2a1a85bd43, %rcx # imm = 0xD6BF94D5E57A42BD
movq %rbx, %rax
imulq %rcx
addq %rbx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x17, %rdx
addq %rax, %rdx
movabsq $-0x2b6109100, %rax # imm = 0xFFFFFFFD49EF6F00
addq %rdx, %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x2160
movq %rax, %rdi
callq 0x20d0
testq %rax, %rax
je 0x131f4
movq %rax, %rbx
movq %rax, %rdi
callq 0x20e0
movq 0xacde9(%rip), %rdi # 0xbffd0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2220
jmp 0x13212
movq 0xacdd5(%rip), %rax # 0xbffd0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x2310
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /aasmirnova7[P]lnk_parser/source/utils/Utils.cpp |
Utils::printSid(std::vector<unsigned int, std::allocator<unsigned int>>, int) | void Utils::printSid(std::vector<unsigned int> vec, int pos) {
cout << hex << vec[pos+3] << " " << hex << vec[pos+2] << " " << hex << vec[pos+1] << " " << hex << vec[pos] << " " << "-" << " " <<
hex << vec[pos+5] << " " << hex << vec[pos+4] << " " << "-" << " " << hex << vec[pos+7] << " " << hex << vec[pos+6] << " " << "-" << " " <<
hex << vec[pos+8] << " " << hex << vec[pos+9] << " " << "-" << " " <<
hex << vec[pos+10] << " " << hex << vec[pos+11] << " " << hex << vec[pos+12] << " " <<
hex << vec[pos+13] << " " << hex << vec[pos+14] << " " << hex << vec[pos+15];
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xacda3(%rip), %rdi # 0xbffd0
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rdi,%rax)
movq (%rbx), %rax
movslq %esi, %r13
movl 0xc(%rax,%r13,4), %esi
callq 0x2130
movq %rax, %r15
leaq 0x53d65(%rip), %r14 # 0x66fc1
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq (%rbx), %rax
movl 0x8(%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq (%rbx), %rax
movl 0x4(%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq (%rbx), %rax
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x2130
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
leaq 0x53fec(%rip), %r15 # 0x6730c
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2220
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r12,%rax)
movq (%rbx), %rax
movl 0x14(%rax,%r13,4), %esi
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r12,%rax)
movq (%rbx), %rax
movl 0x10(%rax,%r13,4), %esi
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2220
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r12,%rax)
movq (%rbx), %rax
movl 0x1c(%rax,%r13,4), %esi
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r12,%rax)
movq (%rbx), %rax
movl 0x18(%rax,%r13,4), %esi
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2220
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r12,%rax)
movq (%rbx), %rax
movl 0x20(%rax,%r13,4), %esi
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r12,%rax)
movq (%rbx), %rax
movl 0x24(%rax,%r13,4), %esi
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2220
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r12,%rax)
movq (%rbx), %rax
movl 0x28(%rax,%r13,4), %esi
movq %r12, %rdi
callq 0x2130
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq (%rbx), %rax
movl 0x2c(%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq (%rbx), %rax
movl 0x30(%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq (%rbx), %rax
movl 0x34(%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq (%rbx), %rax
movl 0x38(%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq (%rbx), %rax
movl 0x3c(%rax,%r13,4), %esi
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2130
nop
| /aasmirnova7[P]lnk_parser/source/utils/Utils.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.