name string | code string | asm string | file string |
|---|---|---|---|
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_d... | 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
mov... | /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] |... | 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 %... | /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) {
... | 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 = 0x3... | /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,... | 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, %r1... | /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_R... | 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(%rd... | /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)... | /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->joypa... | 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
m... | /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... | 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... | /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... | 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... | /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 sys... | 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
c... | /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;
S... | 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 ... | /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... | 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... | /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);
glUni... | 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 ... | /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(%... | /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);
T... | 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 0... | /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;
but... | 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, %ec... | /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.... | 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;... | 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 $0... | /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_... | 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(%... | /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 (%rd... | /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;
... | 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
x... | /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;
} e... | 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... | /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 ... | 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
ca... | /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... | 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),... | /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... | 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... | /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);
#i... | 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 (uns... | 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(po... | 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_CO... | 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 ... | /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->dat... | 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
mo... | /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(listInde... | 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(... | /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... | /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 + r... | 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, %r... | /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... | /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 &... | 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, %... | /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 cur... | 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... | /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++;
... | 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 (%rb... | /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--;
}
... | 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,... | /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) {
... | 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), %r... | /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.... | 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, %ed... | /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) cou... | 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, %rs... | /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--;
... | 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
mo... | /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;
... | 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 (%r... | /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 ... | 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, -... | /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),... | /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 ... | 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 %r1... | /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... | 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)
j... | /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(... | 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, -0... | /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
in... | 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,... | /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)
mo... | /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::end... | 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(%rb... | /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( keyb... | 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 = 0... | /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_... | 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, ... | /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++;
... | 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
mo... | /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++;
... | 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
... | /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( mbe... | 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... | /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 )
... | 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... | /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... | 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(... | /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];
... | 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... | /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,
unsig... | 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 ... | /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_CIP... | 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(... | /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;
}
retur... | 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... | 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... | /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[... | 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 (%r... | /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), %%x... | 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, ... | 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... | /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_GC... | 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), %... | /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,
... | 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
... | /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... | 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 %ra... | /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 ||
MBEDT... | 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 ... | /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_... | 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
mo... | /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) ... | 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... | /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 ] =... | 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(%... | /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 )
... | 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,%r... | /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... | 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
mov... | /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... | 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... | /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( keyb... | 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(%r... | /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_... | 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, ... | /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 )
... | 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, %... | /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... | 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... | /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... | 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, %... | /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 ) )
{
... | 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
... | /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;
... | 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
a... | /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... | 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 # i... | /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... | 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 %e... | /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;
... | 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
... | /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 = e... | 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
m... | /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 += e... | 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), %r... | /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... | 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 0x... | /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 th... | 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 %... | /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] << ' ';
... | 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
m... | /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)); ... | 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,... | /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]... | 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... | /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 # im... | /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... | 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 ... | /aasmirnova7[P]lnk_parser/source/utils/Utils.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.