name
stringlengths 1
4.98k
| code
stringlengths 61
2.07M
| asm
stringlengths 57
12.9M
| file
stringlengths 18
192
|
|---|---|---|---|
af_prim_setenv
|
void af_prim_setenv(af_task_t* task) {
af_global_t* global = task->global;
char* value;
char* name;
af_byte_t* value_addr;
af_cell_t value_len;
af_byte_t* name_addr;
af_cell_t name_len;
int overwrite;
int error = 0;
AF_VERIFY_DATA_STACK_READ(task, 5);
overwrite = *task->data_stack_current++ ? 1 : 0;
name_len = *task->data_stack_current++;
name_addr = (af_byte_t*)(*task->data_stack_current++);
value_len = *task->data_stack_current++;
value_addr = (af_byte_t*)(*task->data_stack_current);
if(!(name = malloc(name_len + 1))) {
af_handle_out_of_memory(global, task);
return;
}
memcpy(name, name_addr, name_len);
name[name_len] = 0;
if(!(value = malloc(value_len + 1))) {
free(name);
af_handle_out_of_memory(global, task);
return;
}
memcpy(value, value_addr, value_len);
value[value_len] = 0;
if(setenv(name, value, overwrite)) {
error = errno;
}
free(value);
free(name);
*task->data_stack_current = error;
AF_ADVANCE_IP(task, 1);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rbp
movq 0x60(%rdi), %rax
cmpq $0x0, (%rax)
setne 0x7(%rsp)
movq 0x8(%rax), %r13
movq 0x10(%rax), %r15
leaq 0x20(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq 0x18(%rax), %r12
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x1(%r13), %rdi
callq 0x2220
testq %rax, %rax
je 0xa740
movq %rax, %r14
movq %rbp, 0x8(%rsp)
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x21f0
movb $0x0, (%r14,%r13)
leaq 0x1(%r12), %rdi
callq 0x2220
testq %rax, %rax
je 0xa745
movq %rax, %r13
xorl %ebp, %ebp
movb 0x7(%rsp), %al
movb %al, %bpl
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
callq 0x21f0
movb $0x0, (%r13,%r12)
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x20e0
testl %eax, %eax
je 0xa768
callq 0x2070
movslq (%rax), %r15
jmp 0xa76b
movq %rbp, %rdi
jmp 0xa752
movq %r14, %rdi
callq 0x2050
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x35b5
xorl %r15d, %r15d
movq %r13, %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2050
movq 0x60(%rbx), %rax
movq %r15, (%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
|
af_prim_to_io_handler_task
|
void af_prim_to_io_handler_task(af_task_t* task) {
af_global_t* global = task->global;
AF_VERIFY_DATA_STACK_READ(task, 1);
af_io_set_handler_task(&global->io,
(af_task_t*)(*task->data_stack_current++));
AF_ADVANCE_IP(task, 1);
}
|
pushq %rbx
movq %rdi, %rbx
movl $0xa8, %edi
addq (%rbx), %rdi
movq 0x60(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x60(%rbx)
movq (%rax), %rsi
callq 0xc4c5
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
popq %rbx
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
|
af_prim_io_action_get_state
|
void af_prim_io_action_get_state(af_task_t* task) {
af_global_t* global = task->global;
af_io_state_t* state;
AF_VERIFY_DATA_STACK_READ(task, 1);
if(!(state = malloc(sizeof(af_io_state_t)))) {
af_handle_out_of_memory(global, task);
return;
}
af_io_action_get_state((af_io_action_t*)(*task->data_stack_current), state);
*task->data_stack_current = (af_cell_t)state;
AF_ADVANCE_IP(task, 1);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
movl $0x40, %edi
callq 0x2220
testq %rax, %rax
je 0xa927
movq %rax, %r14
movq 0x60(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0xc4f2
movq 0x60(%rbx), %rax
movq %r14, (%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x35b5
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
|
af_prim_io_state_has_hangup
|
void af_prim_io_state_has_hangup(af_task_t* task) {
AF_VERIFY_DATA_STACK_READ(task, 1);
*(af_bool_t*)task->data_stack_current =
af_io_state_has_hangup((af_io_state_t*)(*task->data_stack_current));
AF_ADVANCE_IP(task, 1);
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %rdi
callq 0xc554
movq 0x60(%rbx), %rcx
movq %rax, (%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
popq %rbx
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
|
af_prim_io_state_has_error
|
void af_prim_io_state_has_error(af_task_t* task) {
AF_VERIFY_DATA_STACK_READ(task, 1);
*(af_bool_t*)task->data_stack_current =
af_io_state_has_error((af_io_state_t*)(*task->data_stack_current));
AF_ADVANCE_IP(task, 1);
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %rdi
callq 0xc559
movq 0x60(%rbx), %rcx
movq %rax, (%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
popq %rbx
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
|
af_prim_io_state_get_index
|
void af_prim_io_state_get_index(af_task_t* task) {
AF_VERIFY_DATA_STACK_READ(task, 1);
*task->data_stack_current =
af_io_state_get_index((af_io_state_t*)(*task->data_stack_current));
AF_ADVANCE_IP(task, 1);
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %rdi
callq 0xc562
movq 0x60(%rbx), %rcx
movq %rax, (%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
popq %rbx
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
|
af_prim_io_sleep
|
void af_prim_io_sleep(af_task_t* task) {
af_global_t* global = task->global;
af_time_t sleep_until;
af_io_action_t* action;
AF_VERIFY_DATA_STACK_READ(task, 2);
sleep_until.nsec = *task->data_stack_current++;
sleep_until.sec = *task->data_stack_current++;
action = af_io_sleep(&global->io, &sleep_until, task);
af_io_action_destroy(action);
AF_ADVANCE_IP(task, 1);
af_wait(global, task);
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x60(%rdi), %rax
movq (%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, 0x8(%rsi)
leaq 0x10(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq 0x8(%rax), %rax
movq %rax, (%rsi)
leaq 0xa8(%r14), %rdi
movq %rbx, %rdx
callq 0xc82d
movq %rax, %rdi
callq 0xc43c
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31be
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
|
af_prim_io_tell
|
void af_prim_io_tell(af_task_t* task) {
af_global_t* global = task->global;
af_io_action_t* action;
AF_VERIFY_DATA_STACK_READ(task, 1);
action = af_io_tell(&global->io, (af_io_fd_t)(*task->data_stack_current),
task);
*task->data_stack_current = (af_cell_t)action;
AF_ADVANCE_IP(task, 1);
af_wait(global, task);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x60(%rdi), %rax
leaq 0xa8(%r14), %rdi
movl (%rax), %esi
movq %rbx, %rdx
callq 0xc973
movq 0x60(%rbx), %rcx
movq %rax, (%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31be
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
|
af_prim_base_interpreter
|
void af_prim_base_interpreter(af_task_t* task) {
af_global_t* global = task->global;
task->interpreter_pointer = &global->base_interpreter_code[0];
if(af_parse_name_available(global, task)) {
af_cell_t length;
af_byte_t* text = af_parse_name(global, task, &length);
/* char* print_text = malloc(length + 1); */
/* memcpy(print_text, text, length); */
/* print_text[length] = '\0'; */
/* if(task->is_compiling) { */
/* printf("Compiling name: %s\n", print_text) */
/* } else { */
/* printf("Evaluating name: %s\n", print_text); */
/* } */
af_word_t* word = af_lookup(global, task, text, length);
if(word) {
if(task->is_compiling && !(word->flags & AF_WORD_IMMEDIATE)) {
af_compiled_t* slot = af_allot(global, task,
sizeof(af_compiled_t));
if(slot) {
slot->compiled_call = word;
}
} else if(!task->is_compiling && (word->flags & AF_WORD_COMPILE_ONLY)) {
char* buffer = malloc(length + 1);
memcpy(buffer, text, length);
buffer[length] = 0;
printf("%s: ", buffer);
free(buffer);
af_handle_compile_only(global, task);
} else {
AF_WORD_EXECUTE(task, word);
}
} else {
af_sign_cell_t result;
if(af_parse_number(global, task->base, text, (size_t)length, &result)) {
if(task->is_compiling) {
af_compiled_t* slot = af_allot(global, task,
sizeof(af_compiled_t) * 2);
if(slot) {
slot->compiled_call = global->builtin_literal_runtime;
(slot + 1)->compiled_sign_cell = result;
}
} else {
if(--task->data_stack_current >= task->data_stack_top) {
*task->data_stack_current = (af_cell_t)result;
} else {
af_handle_data_stack_overflow(global, task);
}
}
} else {
af_float_t float_result;
if(af_parse_float(global, text, (size_t)length, &float_result)) {
if(task->is_compiling) {
af_compiled_t* slot = af_allot(global, task,
sizeof(af_compiled_t) +
sizeof(af_float_t));
if(slot) {
slot->compiled_call = global->builtin_f_literal_runtime;
*(af_float_t*)(&(slot + 1)->compiled_cell) = float_result;
}
} else {
if(--task->float_stack_current >= task->float_stack_top) {
*task->float_stack_current = float_result;
} else {
af_handle_float_stack_overflow(global, task);
}
}
} else {
af_2cell_t result2;
if(af_parse_2number(global, task->base, text, (size_t)length,
&result2)) {
if(task->is_compiling) {
af_compiled_t* slot = af_allot(global, task,
sizeof(af_compiled_t) * 4);
if(slot) {
slot->compiled_call = global->builtin_literal_runtime;
(slot + 1)->compiled_cell =
(af_cell_t)(result2 &
((~(af_2cell_t)0) >> (sizeof(af_cell_t) << 3)));
(slot + 2)->compiled_call = global->builtin_literal_runtime;
(slot + 3)->compiled_cell =
(af_cell_t)(result2 >> (sizeof(af_cell_t) << 3));
}
} else {
if((task->data_stack_current - 2) >= task->data_stack_top) {
*(--task->data_stack_current) =
(af_cell_t)(result2 &
((~(af_2cell_t)0) >> (sizeof(af_cell_t) << 3)));
*(--task->data_stack_current) =
(af_cell_t)(result2 >> (sizeof(af_cell_t) << 3));
} else {
af_handle_data_stack_overflow(global, task);
}
}
} else {
char* buffer = malloc(length + 1);
memcpy(buffer, text, length);
buffer[length] = 0;
printf("%s: ", buffer);
free(buffer);
af_handle_parse_error(global, task);
}
}
}
}
} else {
af_kill(global, task);
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movq (%rdi), %rbx
leaq 0x1f0(%rbx), %rax
movq %rax, 0x58(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3db4
testq %rax, %rax
je 0xb80c
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3e63
movq %rax, %r15
movq (%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x383e
testq %rax, %rax
je 0xb824
movq %rax, %r12
cmpq $0x0, 0x40(%r14)
movq 0x18(%rax), %rax
je 0xb881
testb $0x1, %al
jne 0xb885
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x377a
testq %rax, %rax
je 0xba90
movq %r12, (%rax)
jmp 0xba90
movq %rbx, %rdi
movq %r14, %rsi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x315d
movq 0xf0(%r14), %rsi
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3892
testq %rax, %rax
je 0xb898
cmpq $0x0, 0x40(%r14)
je 0xb943
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x377a
testq %rax, %rax
je 0xba90
movq 0x180(%rbx), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xba90
testb $0x4, %al
jne 0xb8f4
movq %r12, 0xf8(%r14)
movq %r14, %rdi
callq *(%r12)
jmp 0xba90
movq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x39f3
testq %rax, %rax
je 0xb969
cmpq $0x0, 0x40(%r14)
je 0xb9eb
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x377a
testq %rax, %rax
je 0xba90
movq 0x188(%rbx), %rcx
movq %rcx, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0xba90
movq 0x8(%rsp), %r12
leaq 0x1(%r12), %rdi
callq 0x2220
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x21f0
movb $0x0, (%r13,%r12)
leaq 0x318f(%rip), %rdi # 0xeab0
movq %r13, %rsi
xorl %eax, %eax
callq 0x2130
movq %r13, %rdi
callq 0x2050
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3605
jmp 0xba90
movq 0x60(%r14), %rax
addq $-0x8, %rax
movq %rax, 0x60(%r14)
cmpq 0x78(%r14), %rax
jae 0xb9de
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3425
jmp 0xba90
movq 0xf0(%r14), %rsi
movq 0x8(%rsp), %rcx
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3aa7
testq %rax, %rax
je 0xba10
cmpq $0x0, 0x40(%r14)
je 0xba68
movl $0x20, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x377a
testq %rax, %rax
je 0xba90
movq 0x180(%rbx), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x180(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0xba90
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
jmp 0xba90
movq 0x68(%r14), %rax
addq $-0x8, %rax
movq %rax, 0x68(%r14)
cmpq 0x80(%r14), %rax
jae 0xba5c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x344d
jmp 0xba90
movq 0x8(%rsp), %r12
leaq 0x1(%r12), %rdi
callq 0x2220
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x21f0
movb $0x0, (%r13,%r12)
leaq 0x3073(%rip), %rdi # 0xeab0
movq %r13, %rsi
xorl %eax, %eax
callq 0x2130
movq %r13, %rdi
callq 0x2050
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3565
jmp 0xba90
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0xba90
movq 0x60(%r14), %rax
leaq -0x10(%rax), %rcx
cmpq 0x78(%r14), %rcx
jb 0xb959
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %rdx, -0x8(%rax)
movq %rcx, 0x60(%r14)
movq %rsi, -0x10(%rax)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
|
af_prim_docol
|
void af_prim_docol(af_task_t* task) {
af_global_t* global = task->global;
if(task->return_stack_current > task->return_stack_top) {
*(--task->return_stack_current) = task->interpreter_pointer + 1;
task->interpreter_pointer = task->current_word->secondary;
} else {
af_handle_return_stack_overflow(global, task);
}
}
|
movq %rdi, %rsi
movq 0x70(%rdi), %rax
cmpq 0x88(%rdi), %rax
jbe 0xbad2
movq 0x58(%rsi), %rcx
addq $0x8, %rcx
leaq -0x8(%rax), %rdx
movq %rdx, 0x70(%rsi)
movq %rcx, -0x8(%rax)
movq 0xf8(%rsi), %rax
movq 0x20(%rax), %rax
movq %rax, 0x58(%rsi)
retq
movq (%rsi), %rdi
jmp 0x3475
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
|
af_prim_push_data
|
void af_prim_push_data(af_task_t* task) {
af_global_t* global = task->global;
if(task->data_stack_current > task->data_stack_top) {
*(--task->data_stack_current) =
(af_cell_t)AF_WORD_DATA(task->current_word);
AF_ADVANCE_IP(task, 1);
} else {
af_handle_data_stack_overflow(global, task);
}
}
|
movq %rdi, %rsi
movq 0x60(%rdi), %rax
cmpq 0x78(%rdi), %rax
jbe 0xbb12
movq 0xf8(%rsi), %rcx
addq $0x28, %rcx
leaq -0x8(%rax), %rdx
movq %rdx, 0x60(%rsi)
movq %rcx, -0x8(%rax)
movq 0x58(%rsi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rsi)
retq
movq (%rsi), %rdi
jmp 0x3425
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
|
af_prim_do_does
|
void af_prim_do_does(af_task_t* task) {
af_global_t* global = task->global;
if(task->data_stack_current > task->data_stack_top) {
if(task->return_stack_current > task->return_stack_top) {
*(--task->data_stack_current) =
(af_cell_t)AF_WORD_DATA(task->current_word);
*(--task->return_stack_current) =
task->interpreter_pointer ? task->interpreter_pointer + 1 : NULL;
task->interpreter_pointer = task->current_word->secondary;
} else {
af_handle_return_stack_overflow(global, task);
}
} else {
af_handle_data_stack_overflow(global, task);
}
}
|
movq %rdi, %rsi
movq (%rdi), %rdi
movq 0x60(%rsi), %rcx
cmpq 0x78(%rsi), %rcx
jbe 0x3425
movq 0x70(%rsi), %rax
cmpq 0x88(%rsi), %rax
jbe 0x3475
movq 0xf8(%rsi), %rdx
addq $0x28, %rdx
leaq -0x8(%rcx), %rdi
movq %rdi, 0x60(%rsi)
movq %rdx, -0x8(%rcx)
movq 0x58(%rsi), %rcx
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
cmovneq %rdx, %rcx
leaq -0x8(%rax), %rdx
movq %rdx, 0x70(%rsi)
movq %rcx, -0x8(%rax)
movq 0xf8(%rsi), %rax
movq 0x20(%rax), %rax
movq %rax, 0x58(%rsi)
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
|
af_cond_init
|
af_bool_t af_cond_init(af_cond_t* cond) {
if(pthread_cond_init(&cond->cond, NULL)) {
return FALSE;
}
if(pthread_mutex_init(&cond->mutex, NULL)) {
pthread_cond_destroy(&cond->cond);
return FALSE;
}
cond->count = 0;
return TRUE;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x28(%rdi), %rbx
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2200
testl %eax, %eax
jne 0xbc4f
movq %r14, %rdi
xorl %esi, %esi
callq 0x2300
testl %eax, %eax
je 0xbc40
movq %rbx, %rdi
callq 0x2290
xorl %r15d, %r15d
jmp 0xbc4f
movq $0x0, 0x58(%r14)
movq $-0x1, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/cond.c
|
af_cond_wait
|
void af_cond_wait(af_cond_t* cond) {
pthread_mutex_lock(&cond->mutex);
if(!cond->count) {
pthread_cond_wait(&cond->cond, &cond->mutex);
}
cond->count = 0;
pthread_mutex_unlock(&cond->mutex);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x2310
cmpq $0x0, 0x58(%rbx)
jne 0xbc8a
leaq 0x28(%rbx), %rdi
movq %rbx, %rsi
callq 0x2100
movq $0x0, 0x58(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x2210
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/cond.c
|
af_io_init
|
af_bool_t af_io_init(af_io_t* io, af_global_t* global) {
af_io_fd_t pipefd[2];
if(pthread_mutex_init(&io->mutex, NULL)) {
return FALSE;
}
if(pipe(pipefd)) {
pthread_mutex_destroy(&io->mutex);
return FALSE;
}
io->global = global;
io->break_fd_out = pipefd[0];
io->break_fd_in = pipefd[1];
if(!af_fd_set_blocking(io->break_fd_in, TRUE)) {
close(io->break_fd_out);
close(io->break_fd_in);
pthread_mutex_destroy(&io->mutex);
return FALSE;
}
io->active_action_count = 0;
io->first_active_action = NULL;
io->first_waiting_action = NULL;
io->last_waiting_action = NULL;
io->first_done_action = NULL;
io->to_be_destroyed = FALSE;
io->handler_task = NULL;
if(!af_io_prepare_stdin()) {
close(io->break_fd_out);
close(io->break_fd_in);
pthread_mutex_destroy(&io->mutex);
return FALSE;
}
if(pthread_create(&io->pthread, NULL, af_io_main, io)) {
close(io->break_fd_out);
close(io->break_fd_in);
pthread_mutex_destroy(&io->mutex);
return FALSE;
}
return TRUE;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2300
testl %eax, %eax
jne 0xbd6c
movq %rsp, %rdi
callq 0x2190
testl %eax, %eax
jne 0xbd61
movq %r15, 0x30(%r14)
movl (%rsp), %eax
movl %eax, 0x3c(%r14)
movl 0x4(%rsp), %edi
movl %edi, 0x38(%r14)
movq $-0x1, %rsi
callq 0xbd84
testq %rax, %rax
je 0xbd4f
movq $0x0, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x60(%r14)
movups %xmm0, 0x70(%r14)
callq 0xbdde
testq %rax, %rax
je 0xbd4f
leaq 0xf6(%rip), %rdx # 0xbe34
movq %r14, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x2250
testl %eax, %eax
je 0xbd7b
movl 0x3c(%r14), %edi
callq 0x2180
movl 0x38(%r14), %edi
callq 0x2180
movq %rbx, %rdi
callq 0x2140
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq $-0x1, %r12
jmp 0xbd6c
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_prepare_stdin
|
af_bool_t af_io_prepare_stdin(void) {
struct termios tp;
if(isatty(STDIN_FILENO)) {
if(tcgetattr(STDIN_FILENO, &tp) == -1) {
return FALSE;
}
if(tp.c_lflag & ECHO || tp.c_lflag & ICANON) {
tp.c_lflag &= ~ECHO & ~ICANON;
if(tcsetattr(STDIN_FILENO, TCSANOW, &tp) == -1) {
return FALSE;
}
}
}
return TRUE;
}
|
pushq %rbx
subq $0x40, %rsp
xorl %edi, %edi
callq 0x20a0
testl %eax, %eax
je 0xbe24
xorl %ebx, %ebx
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
callq 0x2270
cmpl $-0x1, %eax
je 0xbe2b
movl 0x10(%rsp), %eax
testb $0xa, %al
je 0xbe24
andl $-0xb, %eax
leaq 0x4(%rsp), %rdx
movl %eax, 0xc(%rdx)
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
callq 0x2280
cmpl $-0x1, %eax
je 0xbe2b
movq $-0x1, %rbx
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_main
|
void* af_io_main(void* arg) {
af_io_t* io = arg;
while(!io->to_be_destroyed) {
af_io_action_t* current_action;
af_cell_t active_fd_count;
struct pollfd* fds;
af_io_action_t** actions;
af_cell_t current_index = 0;
pthread_mutex_lock(&io->mutex);
af_bool_t still_looping;
struct timespec current_time;
struct timespec wait_time;
int used_wait_time = -1;
af_bool_t wait_time_set = FALSE;
clock_gettime(CLOCK_MONOTONIC, ¤t_time);
do {
still_looping = FALSE;
current_action = io->first_active_action;
while(current_action) {
if(current_action->type == AF_IO_TYPE_CLOSE) {
current_action->is_done = TRUE;
close(current_action->fd);
still_looping = TRUE;
} else if(current_action->type == AF_IO_TYPE_READ) {
if(!current_action->count) {
current_action->is_done = TRUE;
still_looping = TRUE;
}
} else if(current_action->type == AF_IO_TYPE_WRITE) {
if(!current_action->count) {
current_action->is_done = TRUE;
still_looping = TRUE;
}
} else if(current_action->type == AF_IO_TYPE_SEEK) {
current_action->is_done = TRUE;
if((lseek(current_action->fd, current_action->offset,
current_action->whence)) == -1) {
current_action->has_error = TRUE;
}
still_looping = TRUE;
} else if(current_action->type == AF_IO_TYPE_TELL) {
current_action->is_done = TRUE;
if((current_action->offset =
lseek(current_action->fd, 0, SEEK_CUR)) == -1) {
current_action->has_error = TRUE;
}
still_looping = TRUE;
} else if(current_action->type == AF_IO_TYPE_SLEEP) {
if(current_time.tv_sec > current_action->sleep_until.tv_sec ||
(current_time.tv_sec == current_action->sleep_until.tv_sec &&
current_time.tv_nsec > current_action->sleep_until.tv_nsec)) {
current_action->is_done = TRUE;
still_looping = TRUE;
} else {
struct timespec current_wait_time;
timespec_diff(¤t_time, ¤t_action->sleep_until,
¤t_wait_time);
if(wait_time_set) {
if(current_wait_time.tv_sec < wait_time.tv_sec ||
(current_wait_time.tv_sec == wait_time.tv_sec &&
current_wait_time.tv_nsec < wait_time.tv_nsec)) {
wait_time.tv_sec = current_wait_time.tv_sec;
wait_time.tv_nsec = current_wait_time.tv_nsec;
}
} else {
wait_time.tv_sec = current_wait_time.tv_sec;
wait_time.tv_nsec = current_wait_time.tv_nsec;
wait_time_set = TRUE;
}
}
}
current_action = current_action->next_action;
}
af_io_remove_done(io);
} while(still_looping);
if(!(fds = malloc(sizeof(struct pollfd) * (io->active_action_count + 1)))) {
close(io->break_fd_out);
close(io->break_fd_in);
pthread_mutex_destroy(&io->mutex);
return NULL;
}
if(!(actions = malloc(sizeof(af_io_action_t*) * io->active_action_count))) {
free(fds);
close(io->break_fd_out);
close(io->break_fd_in);
pthread_mutex_destroy(&io->mutex);
return NULL;
}
current_action = io->first_active_action;
while(current_action) {
if(current_action->type != AF_IO_TYPE_CLOSE &&
current_action->type != AF_IO_TYPE_SEEK &&
current_action->type != AF_IO_TYPE_TELL &&
current_action->type != AF_IO_TYPE_SLEEP) {
fds[current_index].fd = current_action->fd;
if(current_action->type == AF_IO_TYPE_READ) {
fds[current_index].events = POLLIN;
} else {
fds[current_index].events = POLLOUT;
}
actions[current_index] = current_action;
fds[current_index++].revents = 0;
}
current_action = current_action->next_action;
}
fds[current_index].fd = io->break_fd_out;
fds[current_index].events = POLLIN;
fds[current_index].revents = 0;
pthread_mutex_unlock(&io->mutex);
if(wait_time_set) {
used_wait_time =
(wait_time.tv_sec * 1000) + (wait_time.tv_nsec / 1000000);
}
if((active_fd_count = poll(fds, current_index + 1, used_wait_time))
!= -1) {
af_cell_t current_active_index = 0;
pthread_mutex_lock(&io->mutex);
clock_gettime(CLOCK_MONOTONIC, ¤t_time);
current_action = io->first_active_action;
while(current_action) {
if(current_action->type == AF_IO_TYPE_SLEEP) {
if(current_time.tv_sec > current_action->sleep_until.tv_sec ||
(current_time.tv_sec == current_action->sleep_until.tv_sec &&
current_time.tv_nsec > current_action->sleep_until.tv_nsec)) {
current_action->is_done = TRUE;
}
}
current_action = current_action->next_action;
}
while(current_active_index < current_index) {
if(fds[current_active_index].revents & POLLHUP) {
actions[current_active_index]->has_hangup = TRUE;
}
if(fds[current_active_index].revents & POLLERR) {
actions[current_active_index]->is_done = TRUE;
actions[current_active_index]->has_error = TRUE;
}
if(fds[current_active_index].revents & POLLIN) {
if(actions[current_active_index]->type == AF_IO_TYPE_READ) {
if(actions[current_active_index]->fd == STDIN_FILENO) {
af_io_prepare_stdin();
}
ssize_t size = read(actions[current_active_index]->fd,
actions[current_active_index]->buffer +
actions[current_active_index]->index,
actions[current_active_index]->count -
actions[current_active_index]->index);
if(size > 0) {
actions[current_active_index]->index += size;
if(actions[current_active_index]->index >=
actions[current_active_index]->count) {
actions[current_active_index]->is_done = TRUE;
}
} else if (!size) {
actions[current_active_index]->is_done = TRUE;
actions[current_active_index]->is_closed = TRUE;
} else if(errno == EAGAIN ||
errno == EWOULDBLOCK ||
errno == EINTR) {
/* Do nothing */
} else {
actions[current_active_index]->is_done = TRUE;
actions[current_active_index]->is_closed = TRUE;
actions[current_active_index]->has_error = TRUE;
}
}
}
if(fds[current_active_index].revents & POLLOUT) {
if(actions[current_active_index]->type == AF_IO_TYPE_WRITE) {
ssize_t size = write(actions[current_active_index]->fd,
actions[current_active_index]->buffer +
actions[current_active_index]->index,
actions[current_active_index]->count -
actions[current_active_index]->index);
if(size > 0) {
actions[current_active_index]->index += size;
if(actions[current_active_index]->index >=
actions[current_active_index]->count) {
actions[current_active_index]->is_done = TRUE;
}
} else if (!size) {
actions[current_active_index]->is_done = TRUE;
actions[current_active_index]->is_closed = TRUE;
} else if(errno == EAGAIN ||
errno == EWOULDBLOCK ||
errno == EINTR) {
/* Do nothing */
} else {
actions[current_active_index]->is_done = TRUE;
actions[current_active_index]->is_closed = TRUE;
actions[current_active_index]->has_error = TRUE;
}
}
}
current_active_index++;
}
if(fds[current_index].revents & POLLERR ||
fds[current_index].revents & POLLHUP) {
free(actions);
free(fds);
close(io->break_fd_out);
close(io->break_fd_in);
pthread_mutex_destroy(&io->mutex);
return NULL;
}
if(fds[current_index].revents & POLLIN) {
af_byte_t buffer;
ssize_t size = read(io->break_fd_out, &buffer, sizeof(af_byte_t));
if(size > 0) {
/* Do nothing */
} else if (size == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
/* Do nothing */
} else {
free(actions);
free(fds);
close(io->break_fd_out);
close(io->break_fd_in);
pthread_mutex_destroy(&io->mutex);
return NULL;
}
}
free(actions);
free(fds);
af_io_remove_done(io);
pthread_mutex_unlock(&io->mutex);
} else {
free(actions);
free(fds);
close(io->break_fd_out);
close(io->break_fd_in);
pthread_mutex_destroy(&io->mutex);
return NULL;
}
}
close(io->break_fd_out);
close(io->break_fd_in);
pthread_mutex_destroy(&io->mutex);
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
cmpq $0x0, 0x70(%rdi)
je 0xbe6a
movl 0x3c(%r15), %edi
callq 0x2180
movl 0x38(%r15), %edi
callq 0x2180
addq $0x8, %r15
movq %r15, %rdi
jmp 0xc355
leaq 0x8(%r15), %r14
leaq 0x2c5b(%rip), %rbx # 0xead0
movq %r14, 0x10(%rsp)
movq %r15, (%rsp)
movq %r14, %rdi
callq 0x2310
movl $0x1, %edi
leaq 0x20(%rsp), %rsi
callq 0x20d0
xorl %r13d, %r13d
movq 0x50(%r15), %r14
testq %r14, %r14
je 0xbfd4
xorl %r12d, %r12d
movq 0x18(%r14), %rax
cmpq $0x5, %rax
ja 0xbfb4
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
cmpq $0x0, 0x38(%r14)
jne 0xbfb4
jmp 0xbeda
movq 0x20(%rsp), %rax
movq 0x58(%r14), %rcx
cmpq %rcx, %rax
jle 0xbf52
movq $-0x1, 0x78(%r14)
jmp 0xbef5
movq $-0x1, 0x78(%r14)
movl 0x28(%r14), %edi
callq 0x2180
movq $-0x1, %r12
jmp 0xbfb4
movq $-0x1, 0x78(%r14)
movl 0x28(%r14), %edi
movq 0x48(%r14), %rsi
movl 0x50(%r14), %edx
callq 0x2160
jmp 0xbf38
movq $-0x1, 0x78(%r14)
movl 0x28(%r14), %edi
xorl %esi, %esi
movl $0x1, %edx
callq 0x2160
movq %rax, 0x48(%r14)
movq $-0x1, %r12
cmpq $-0x1, %rax
jne 0xbfb4
movq $-0x1, 0x90(%r14)
jmp 0xbfb4
jne 0xbf68
movq 0x28(%rsp), %rsi
movq 0x60(%r14), %rdi
cmpq %rdi, %rsi
jg 0xbeda
jmp 0xbf71
movq 0x60(%r14), %rdi
movq 0x28(%rsp), %rsi
leaq 0x3b9aca00(%rdi), %rdx
movq %rax, %r8
negq %r8
cmpq %rsi, %rdi
notq %rax
cmovgeq %r8, %rax
cmovgeq %rdi, %rdx
addq %rcx, %rax
subq %rsi, %rdx
testq %r13, %r13
je 0xbfa5
cmpq 0x18(%rsp), %rax
jl 0xbfa5
jne 0xbfad
cmpq %rbp, %rdx
jge 0xbfad
movq %rdx, %rbp
movq %rax, 0x18(%rsp)
movq $-0x1, %r13
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xbea8
movq %r15, %rdi
callq 0xcfa6
testq %r12, %r12
jne 0xbe98
jmp 0xbfdc
movq %r15, %rdi
callq 0xcfa6
movq %rbp, 0x30(%rsp)
movq 0x40(%r15), %r12
leaq 0x8(,%r12,8), %rdi
callq 0x2220
testq %rax, %rax
je 0xc33c
movq %rax, %rbp
shlq $0x3, %r12
movq %r12, %rdi
callq 0x2220
testq %rax, %rax
je 0xc334
movq %rax, %r12
movq (%rsp), %rax
movq 0x50(%rax), %rax
xorl %r14d, %r14d
testq %rax, %rax
je 0xc064
movq 0x18(%rax), %rcx
leaq -0x2(%rcx), %rdx
cmpq $0x4, %rdx
jb 0xc05e
movl 0x28(%rax), %edx
movl %edx, (%rbp,%r14,8)
xorl %edx, %edx
testq %rcx, %rcx
setne %dl
leal (%rdx,%rdx,2), %ecx
incl %ecx
movw %cx, 0x4(%rbp,%r14,8)
movq %rax, (%r12,%r14,8)
movw $0x0, 0x6(%rbp,%r14,8)
incq %r14
movq 0x8(%rax), %rax
jmp 0xc021
movq (%rsp), %rax
movl 0x3c(%rax), %eax
movl %eax, (%rbp,%r14,8)
movl $0x1, 0x4(%rbp,%r14,8)
movq 0x10(%rsp), %rdi
callq 0x2210
testq %r13, %r13
je 0xc0b3
imull $0x3e8, 0x18(%rsp), %ecx # imm = 0x3E8
movq 0x30(%rsp), %rax
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x12, %rdx
addl %eax, %edx
addl %ecx, %edx
jmp 0xc0b8
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
leaq 0x1(%r14), %rsi
movq %rbp, %rdi
callq 0x2240
cmpl $-0x1, %eax
movq 0x10(%rsp), %r15
je 0xc303
movq %r15, %rdi
callq 0x2310
movl $0x1, %edi
leaq 0x20(%rsp), %rsi
callq 0x20d0
movq (%rsp), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0xc128
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rdx
cmpq $0x4, 0x18(%rax)
jne 0xc11f
cmpq 0x58(%rax), %rcx
jle 0xc117
movq $-0x1, 0x78(%rax)
jmp 0xc11f
jne 0xc11f
cmpq 0x60(%rax), %rdx
jg 0xc10d
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0xc100
testq %r14, %r14
je 0xc280
xorl %r13d, %r13d
movzwl 0x6(%rbp,%r13,8), %eax
testb $0x10, %al
je 0xc14d
movq (%r12,%r13,8), %rcx
movq $-0x1, 0x88(%rcx)
testb $0x8, %al
je 0xc167
movq (%r12,%r13,8), %rcx
movq $-0x1, %rdx
movq %rdx, 0x78(%rcx)
movq %rdx, 0x90(%rcx)
testb $0x1, %al
je 0xc176
movq (%r12,%r13,8), %r15
cmpq $0x0, 0x18(%r15)
je 0xc1c9
testb $0x4, 0x6(%rbp,%r13,8)
je 0xc23d
movq (%r12,%r13,8), %r15
cmpq $0x1, 0x18(%r15)
jne 0xc23d
movl 0x28(%r15), %edi
movq 0x40(%r15), %rax
movq 0x30(%r15), %rsi
addq %rax, %rsi
movq 0x38(%r15), %rdx
subq %rax, %rdx
callq 0x20f0
testq %rax, %rax
jle 0xc215
addq 0x40(%r15), %rax
movq %rax, 0x40(%r15)
cmpq 0x38(%r15), %rax
jb 0xc23d
movq $-0x1, 0x78(%r15)
jmp 0xc23d
movl 0x28(%r15), %edi
testl %edi, %edi
jne 0xc1da
callq 0xbdde
movl 0x28(%r15), %edi
movq 0x38(%r15), %rdx
movq 0x40(%r15), %rax
movq 0x30(%r15), %rsi
addq %rax, %rsi
subq %rax, %rdx
callq 0x21c0
testq %rax, %rax
jle 0xc24b
addq 0x40(%r15), %rax
movq %rax, 0x40(%r15)
cmpq 0x38(%r15), %rax
jb 0xc176
movq $-0x1, 0x78(%r15)
jmp 0xc176
je 0xc233
callq 0x2070
movl (%rax), %eax
cmpl $0x4, %eax
je 0xc23d
cmpl $0xb, %eax
je 0xc23d
movq $-0x1, 0x90(%r15)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x78(%r15)
incq %r13
cmpq %r13, %r14
jne 0xc134
jmp 0xc280
je 0xc271
callq 0x2070
movl (%rax), %eax
cmpl $0x4, %eax
je 0xc176
cmpl $0xb, %eax
je 0xc176
movq $-0x1, 0x90(%r15)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x78(%r15)
jmp 0xc176
movzwl 0x6(%rbp,%r14,8), %eax
testb $0x18, %al
jne 0xc32c
testb $0x1, %al
movq 0x10(%rsp), %r14
je 0xc2ca
movq (%rsp), %rax
movl 0x3c(%rax), %edi
movl $0x1, %edx
leaq 0xf(%rsp), %rsi
callq 0x21c0
testq %rax, %rax
jg 0xc2ca
cmpq $-0x1, %rax
jne 0xc36b
callq 0x2070
cmpl $0xb, (%rax)
jne 0xc36b
movq %r12, %rdi
callq 0x2050
movq %rbp, %rdi
callq 0x2050
movq (%rsp), %r15
movq %r15, %rdi
callq 0xcfa6
movq %r14, %rdi
callq 0x2210
cmpq $0x0, 0x70(%r15)
movq 0x30(%rsp), %rbp
je 0xbe7e
jmp 0xbe4c
movq %r12, %rdi
callq 0x2050
movq %rbp, %rdi
callq 0x2050
movq (%rsp), %rbx
movl 0x3c(%rbx), %edi
callq 0x2180
movl 0x38(%rbx), %edi
callq 0x2180
jmp 0xbe62
movq %r12, %rdi
callq 0x2050
movq %rbp, %rdi
callq 0x2050
movq (%rsp), %rbx
movl 0x3c(%rbx), %edi
callq 0x2180
movl 0x38(%rbx), %edi
callq 0x2180
movq 0x10(%rsp), %rdi
callq 0x2140
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x2050
movq %rbp, %rdi
callq 0x2050
movq (%rsp), %rbx
movl 0x3c(%rbx), %edi
callq 0x2180
movl 0x38(%rbx), %edi
callq 0x2180
movq %r14, %rdi
jmp 0xc355
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_cleanup_stdin
|
af_bool_t af_io_cleanup_stdin(void) {
struct termios tp;
af_fd_set_blocking(STDIN_FILENO, TRUE);
if(isatty(STDIN_FILENO)) {
if(tcgetattr(STDIN_FILENO, &tp) == -1) {
return FALSE;
}
if(!(tp.c_lflag & ECHO) || !(tp.c_lflag & ICANON)) {
tp.c_lflag |= ECHO | ICANON;
if(tcsetattr(STDIN_FILENO, TCSANOW, &tp) == -1) {
return FALSE;
}
}
}
return TRUE;
}
|
pushq %rbx
subq $0x40, %rsp
movq $-0x1, %rbx
xorl %edi, %edi
movq $-0x1, %rsi
callq 0xbd84
xorl %edi, %edi
callq 0x20a0
testl %eax, %eax
je 0xc3f2
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
callq 0x2270
cmpl $-0x1, %eax
je 0xc3f0
movl 0x10(%rsp), %eax
movl %eax, %ecx
notl %ecx
testb $0xa, %cl
je 0xc3f2
orl $0xa, %eax
leaq 0x4(%rsp), %rdx
movl %eax, 0xc(%rdx)
xorl %edi, %edi
xorl %esi, %esi
callq 0x2280
cmpl $-0x1, %eax
jne 0xc3f2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_action_destroy
|
void af_io_action_destroy(af_io_action_t* action) {
af_io_t* io = action->io;
pthread_mutex_lock(&io->mutex);
if(action->is_done) {
if(action->prev_action) {
action->prev_action->next_action = action->next_action;
} else {
io->first_done_action = action->next_action;
}
if(action->next_action) {
action->next_action->prev_action = action->prev_action;
}
free(action);
} else {
action->to_be_destroyed = TRUE;
}
pthread_mutex_unlock(&io->mutex);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
leaq 0x8(%r15), %rbx
movq %rbx, %rdi
callq 0x2310
cmpq $0x0, 0x78(%r14)
je 0xc486
movq (%r14), %rax
movq 0x8(%r14), %rcx
addq $0x68, %r15
leaq 0x8(%rax), %rdx
testq %rax, %rax
cmoveq %r15, %rdx
movq %rcx, (%rdx)
testq %rcx, %rcx
je 0xc47c
movq %rax, (%rcx)
movq %r14, %rdi
callq 0x2050
jmp 0xc48e
movq $-0x1, 0x20(%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2210
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_open
|
af_io_fd_t af_io_open(af_byte_t* path, af_io_size_t count, af_io_flags_t flags,
af_io_mode_t mode, af_io_error_t* error) {
af_byte_t* path_buffer = malloc(sizeof(af_byte_t) * (count + 1));
af_io_fd_t fd;
memcpy(path_buffer, path, count);
path_buffer[count] = 0;
if((fd = open(path_buffer, flags, mode)) >= 0) {
*error = 0;
free(path_buffer);
return fd;
} else {
*error = errno;
free(path_buffer);
return -1;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
leaq 0x1(%rsi), %rdi
callq 0x2220
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x21f0
movb $0x0, (%r14,%r12)
xorl %r12d, %r12d
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x22a0
movl %eax, %ebp
testl %eax, %eax
jns 0xc5ce
callq 0x2070
movl (%rax), %r12d
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x2050
movl %r12d, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_pipe
|
af_bool_t af_io_pipe(af_io_fd_t* in, af_io_fd_t* out, af_io_error_t* error) {
af_io_fd_t fds[2];
if(!pipe(fds)) {
*out = fds[0];
*in = fds[1];
*error = 0;
return TRUE;
} else {
*error = errno;
return FALSE;
}
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
callq 0x2190
testl %eax, %eax
je 0xc615
callq 0x2070
movl (%rax), %ecx
xorl %eax, %eax
jmp 0xc62c
movl 0x8(%rsp), %eax
movl %eax, (%r15)
movl 0xc(%rsp), %eax
movl %eax, (%r14)
movq $-0x1, %rax
xorl %ecx, %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_delete
|
af_bool_t af_io_delete(af_byte_t* path, af_io_size_t count,
af_io_error_t* error) {
af_byte_t* path_buffer = malloc(sizeof(af_byte_t) * (count + 1));
memcpy(path_buffer, path, count);
path_buffer[count] = 0;
if(!unlink(path_buffer)) {
*error = 0;
free(path_buffer);
return TRUE;
} else {
*error = errno;
free(path_buffer);
return FALSE;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x1(%rsi), %rdi
callq 0x2220
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x21f0
movb $0x0, (%r14,%r15)
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xc680
callq 0x2070
movl (%rax), %ebp
xorl %r15d, %r15d
jmp 0xc689
movq $-0x1, %r15
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2050
movl %ebp, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_rename
|
af_bool_t af_io_rename(af_byte_t* path1, af_io_size_t count1,
af_byte_t* path2, af_io_size_t count2,
af_io_error_t* error) {
af_byte_t* path_buffer1 = malloc(sizeof(af_byte_t) * (count1 + 1));
af_byte_t* path_buffer2 = malloc(sizeof(af_byte_t) * (count2 + 1));
memcpy(path_buffer1, path1, count1);
path_buffer1[count1] = 0;
memcpy(path_buffer2, path2, count2);
path_buffer2[count2] = 0;
if(!rename(path_buffer1, path_buffer2)) {
*error = 0;
free(path_buffer1);
free(path_buffer2);
return TRUE;
} else {
*error = errno;
free(path_buffer1);
free(path_buffer2);
return TRUE;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x1(%rsi), %rdi
callq 0x2220
movq %rax, %r14
leaq 0x1(%r12), %rdi
callq 0x2220
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x21f0
xorl %ebx, %ebx
movb %bl, (%r14,%rbp)
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x21f0
movb %bl, (%r15,%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0x22b0
testl %eax, %eax
je 0xc776
callq 0x2070
movl (%rax), %ebx
movq %r14, %rdi
callq 0x2050
movq %r15, %rdi
callq 0x2050
movq (%rsp), %rax
movl %ebx, (%rax)
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_isatty
|
af_bool_t af_io_isatty(af_io_fd_t fd, af_io_error_t* error) {
if(isatty(fd)) {
*error = 0;
return TRUE;
} else if(errno == EINVAL || errno == ENOTTY) {
*error = 0;
return FALSE;
} else {
*error = errno;
return FALSE;
}
}
|
pushq %rbx
movq %rsi, %rbx
callq 0x20a0
testl %eax, %eax
je 0xc7bc
movq $-0x1, %rax
xorl %ecx, %ecx
movl %ecx, (%rbx)
popq %rbx
retq
callq 0x2070
movl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x16, %edx
je 0xc7da
movl $0x0, %eax
cmpl $0x19, %edx
je 0xc7b8
xorl %eax, %eax
movl %edx, %ecx
jmp 0xc7b8
xorl %eax, %eax
jmp 0xc7b8
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_sleep
|
af_io_action_t* af_io_sleep(af_io_t* io, af_time_t* sleep_until,
af_task_t* task_to_wake) {
af_io_action_t* action;
if(!(action = malloc(sizeof(af_io_action_t)))) {
return NULL;
}
action->type = AF_IO_TYPE_SLEEP;
action->to_be_destroyed = FALSE;
action->fd = 0;
action->buffer = NULL;
action->count = 0;
action->index = 0;
action->offset = 0;
action->whence = AF_IO_SEEK_CUR;
action->sleep_until.tv_sec = sleep_until->sec;
action->sleep_until.tv_nsec = sleep_until->nsec;
action->is_buffer_freeable = FALSE;
action->task_to_wake = task_to_wake;
action->is_done = FALSE;
action->is_closed = FALSE;
action->has_hangup = FALSE;
action->has_error = FALSE;
af_io_add(io, action);
return action;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xc89f
movq $0x4, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movl $0x0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movq $0x1, 0x50(%rbx)
movups (%r12), %xmm1
movups %xmm1, 0x58(%rbx)
movq %rax, 0x68(%rbx)
movq %r15, 0x70(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_add
|
void af_io_add(af_io_t* io, af_io_action_t* action) {
af_bool_t wake = FALSE;
pthread_mutex_lock(&io->mutex);
action->io = io;
if(action->type == AF_IO_TYPE_WRITE) {
io->pending_write_count++;
}
if(action->type != AF_IO_TYPE_SLEEP && af_io_is_active(io, action->fd)) {
action->prev_action = io->last_waiting_action;
action->next_action = NULL;
if(action->prev_action) {
action->prev_action->next_action = action;
} else {
io->first_waiting_action = action;
}
io->last_waiting_action = action;
} else {
action->prev_action = NULL;
action->next_action = io->first_active_action;
if(action->next_action) {
action->next_action->prev_action = action;
}
io->first_active_action = action;
io->active_action_count++;
wake = TRUE;
}
pthread_mutex_unlock(&io->mutex);
if(wake) {
af_io_wake(io);
}
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x2310
movq %rbx, 0x10(%r15)
movq 0x18(%r15), %rax
cmpq $0x1, %rax
je 0xc8df
cmpq $0x4, %rax
jne 0xc8e3
movq 0x50(%rbx), %rax
jmp 0xc908
incq 0x48(%rbx)
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0xc91d
movl 0x28(%r15), %ecx
movq %rax, %rdx
cmpl %ecx, 0x28(%rdx)
jne 0xc8ff
cmpq $0x4, 0x18(%rdx)
jne 0xc941
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
jne 0xc8f3
movq $0x0, (%r15)
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0xc924
movq %r15, (%rax)
jmp 0xc924
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq %r15, 0x50(%rbx)
incq 0x40(%rbx)
movq %r14, %rdi
callq 0x2210
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc408
movq 0x60(%rbx), %rax
movq %rax, (%r15)
leaq 0x58(%rbx), %rcx
leaq 0x8(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq $0x0, 0x8(%r15)
movq %r15, (%rdx)
movq %r15, 0x60(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2210
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_tell
|
af_io_action_t* af_io_tell(af_io_t* io, af_io_fd_t fd,
af_task_t* task_to_wake) {
af_io_action_t* action;
if(!(action = malloc(sizeof(af_io_action_t)))) {
return NULL;
}
action->type = AF_IO_TYPE_TELL;
action->to_be_destroyed = FALSE;
action->fd = fd;
action->buffer = NULL;
action->count = 0;
action->index = 0;
action->offset = 0;
action->whence = AF_IO_SEEK_CUR;
action->sleep_until.tv_sec = 0;
action->sleep_until.tv_nsec = 0;
action->is_buffer_freeable = FALSE;
action->task_to_wake = task_to_wake;
action->is_done = FALSE;
action->is_closed = FALSE;
action->has_hangup = FALSE;
action->has_error = FALSE;
af_io_add(io, action);
return action;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xc9da
movq $0x5, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movq $0x1, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
movq %rax, 0x68(%rbx)
movq %r15, 0x70(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_close_async
|
af_io_action_t* af_io_close_async(af_io_t* io, af_io_fd_t fd) {
af_io_action_t* action;
if(!(action = malloc(sizeof(af_io_action_t)))) {
return NULL;
}
action->type = AF_IO_TYPE_CLOSE;
action->to_be_destroyed = FALSE;
action->fd = fd;
action->buffer = NULL;
action->count = 0;
action->index = 0;
action->offset = 0;
action->whence = AF_IO_SEEK_CUR;
action->sleep_until.tv_sec = 0;
action->sleep_until.tv_nsec = 0;
action->is_buffer_freeable = FALSE;
action->task_to_wake = NULL;
action->is_done = FALSE;
action->is_closed = FALSE;
action->has_hangup = FALSE;
action->has_error = FALSE;
af_io_add(io, action);
return action;
}
|
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xcabc
movq $0x2, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movq $0x1, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_seek_block
|
af_io_action_t* af_io_seek_block(af_io_t* io, af_io_fd_t fd, af_io_off_t offset,
af_io_whence_t whence,
af_task_t* task_to_wake) {
af_io_action_t* action;
if(!(action = malloc(sizeof(af_io_action_t)))) {
return NULL;
}
action->type = AF_IO_TYPE_SEEK;
action->to_be_destroyed = FALSE;
action->fd = fd;
action->buffer = NULL;
action->count = 0;
action->index = 0;
action->offset = offset;
action->whence = whence;
action->sleep_until.tv_sec = 0;
action->sleep_until.tv_nsec = 0;
action->is_buffer_freeable = FALSE;
action->task_to_wake = task_to_wake;
action->is_done = FALSE;
action->is_closed = FALSE;
action->has_hangup = FALSE;
action->has_error = FALSE;
af_io_add(io, action);
return action;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xcb39
movq $0x3, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movl %r13d, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq %rax, 0x40(%rbx)
movq %r12, 0x48(%rbx)
movslq %ebp, %rcx
movq %rcx, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
movq %rax, 0x68(%rbx)
movq %r15, 0x70(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_seek_async
|
af_io_action_t* af_io_seek_async(af_io_t* io, af_io_fd_t fd, af_io_off_t offset,
af_io_whence_t whence) {
af_io_action_t* action;
if(!(action = malloc(sizeof(af_io_action_t)))) {
return NULL;
}
action->type = AF_IO_TYPE_SEEK;
action->to_be_destroyed = FALSE;
action->fd = fd;
action->buffer = NULL;
action->count = 0;
action->index = 0;
action->offset = offset;
action->whence = whence;
action->sleep_until.tv_sec = 0;
action->sleep_until.tv_nsec = 0;
action->is_buffer_freeable = FALSE;
action->task_to_wake = NULL;
action->is_done = FALSE;
action->is_closed = FALSE;
action->has_hangup = FALSE;
action->has_error = FALSE;
af_io_add(io, action);
return action;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xcbb6
movq $0x3, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movl %r12d, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq %rax, 0x40(%rbx)
movq %r15, 0x48(%rbx)
movslq %ebp, %rax
movq %rax, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_read_block
|
af_io_action_t* af_io_read_block(af_io_t* io, af_io_fd_t fd, af_byte_t* buffer,
af_io_size_t count, af_task_t* task_to_wake) {
af_io_action_t* action;
if(!(action = malloc(sizeof(af_io_action_t)))) {
return NULL;
}
action->type = AF_IO_TYPE_READ;
action->to_be_destroyed = FALSE;
action->fd = fd;
action->buffer = buffer;
action->count = count;
action->index = 0;
action->offset = 0;
action->whence = AF_IO_SEEK_CUR;
action->sleep_until.tv_sec = 0;
action->sleep_until.tv_nsec = 0;
action->is_buffer_freeable = FALSE;
action->task_to_wake = task_to_wake;
action->is_done = count == 0;
action->is_closed = FALSE;
action->has_hangup = FALSE;
action->has_error = FALSE;
af_fd_set_blocking(fd, FALSE);
af_io_add(io, action);
return action;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xcc47
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movl %ebp, 0x28(%rbx)
movq %r13, 0x30(%rbx)
movq %r15, 0x38(%rbx)
movups %xmm0, 0x40(%rbx)
movq $0x1, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
xorl %eax, %eax
movq %rax, 0x68(%rbx)
movq %r12, 0x70(%rbx)
xorl %ecx, %ecx
testq %r15, %r15
sete %cl
movq %rcx, 0x78(%rbx)
movups %xmm0, 0x80(%rbx)
movq %rax, 0x90(%rbx)
movl %ebp, %edi
xorl %esi, %esi
callq 0xbd84
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_write_block
|
af_io_action_t* af_io_write_block(af_io_t* io, af_io_fd_t fd, af_byte_t* buffer,
af_io_size_t count, af_task_t* task_to_wake) {
af_io_action_t* action;
if(!(action = malloc(sizeof(af_io_action_t)))) {
return NULL;
}
action->type = AF_IO_TYPE_WRITE;
action->to_be_destroyed = FALSE;
action->fd = fd;
action->buffer = buffer;
action->count = count;
action->index = 0;
action->offset = 0;
action->whence = AF_IO_SEEK_CUR;
action->sleep_until.tv_sec = 0;
action->sleep_until.tv_nsec = 0;
action->is_buffer_freeable = FALSE;
action->task_to_wake = task_to_wake;
action->is_done = count == 0;
action->is_closed = FALSE;
action->has_hangup = FALSE;
action->has_error = FALSE;
af_fd_set_blocking(fd, FALSE);
af_io_add(io, action);
return action;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xcce3
movl $0x1, %eax
movq %rax, 0x18(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
movq %r13, 0x30(%rbx)
movq %r15, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq %rax, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
movq %rcx, 0x68(%rbx)
movq %r12, 0x70(%rbx)
xorl %eax, %eax
testq %r15, %r15
sete %al
movq %rax, 0x78(%rbx)
movups %xmm0, 0x80(%rbx)
movq %rcx, 0x90(%rbx)
movl %ebp, %edi
xorl %esi, %esi
callq 0xbd84
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_read_async
|
af_io_action_t* af_io_read_async(af_io_t* io, af_io_fd_t fd, af_byte_t* buffer,
af_io_size_t count) {
af_io_action_t* action;
if(!(action = malloc(sizeof(af_io_action_t)))) {
return NULL;
}
action->type = AF_IO_TYPE_READ;
action->to_be_destroyed = FALSE;
action->fd = fd;
action->buffer = buffer;
action->count = count;
action->index = 0;
action->offset = 0;
action->whence = AF_IO_SEEK_CUR;
action->sleep_until.tv_sec = 0;
action->sleep_until.tv_nsec = 0;
action->is_buffer_freeable = FALSE;
action->task_to_wake = NULL;
action->is_done = count == 0;
action->is_closed = FALSE;
action->has_hangup = FALSE;
action->has_error = FALSE;
af_fd_set_blocking(fd, FALSE);
af_io_add(io, action);
return action;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xcd72
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movl %ebp, 0x28(%rbx)
movq %r12, 0x30(%rbx)
movq %r15, 0x38(%rbx)
movups %xmm0, 0x40(%rbx)
movq $0x1, 0x50(%rbx)
xorl %eax, %eax
testq %r15, %r15
sete %al
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rax, 0x78(%rbx)
movups %xmm0, 0x80(%rbx)
movq $0x0, 0x90(%rbx)
movl %ebp, %edi
xorl %esi, %esi
callq 0xbd84
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_write_async
|
af_io_action_t* af_io_write_async(af_io_t* io, af_io_fd_t fd, af_byte_t* buffer,
af_io_size_t count) {
af_io_action_t* action;
af_byte_t* buffer_copy;
if(!(action = malloc(sizeof(af_io_action_t)))) {
return NULL;
}
if(!(buffer_copy = malloc(sizeof(af_byte_t) * count))) {
free(action);
return NULL;
}
memcpy(buffer_copy, buffer, sizeof(af_byte_t) * count);
action->type = AF_IO_TYPE_WRITE;
action->to_be_destroyed = FALSE;
action->fd = fd;
action->buffer = buffer_copy;
action->count = count;
action->index = 0;
action->offset = 0;
action->whence = AF_IO_SEEK_CUR;
action->sleep_until.tv_sec = 0;
action->sleep_until.tv_nsec = 0;
action->is_buffer_freeable = TRUE;
action->task_to_wake = NULL;
action->is_done = count == 0;
action->is_closed = FALSE;
action->has_hangup = FALSE;
action->has_error = FALSE;
af_fd_set_blocking(fd, FALSE);
af_io_add(io, action);
return action;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
testq %rax, %rax
je 0xce35
movq %rax, %rbx
movq %r15, %rdi
callq 0x2220
testq %rax, %rax
je 0xce2d
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x21f0
movl $0x1, %eax
movq %rax, 0x18(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
movq %r13, 0x30(%rbx)
movq %r15, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq %rax, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
movq $-0x1, 0x68(%rbx)
movq %rcx, 0x70(%rbx)
xorl %eax, %eax
testq %r15, %r15
sete %al
movq %rax, 0x78(%rbx)
movups %xmm0, 0x80(%rbx)
movq %rcx, 0x90(%rbx)
movl %ebp, %edi
xorl %esi, %esi
callq 0xbd84
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
jmp 0xce37
movq %rbx, %rdi
callq 0x2050
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_read_nonblock
|
ssize_t af_io_read_nonblock(int fd, af_byte_t* buffer, af_io_size_t count,
af_bool_t* again, af_io_error_t* error) {
ssize_t size;
af_fd_set_blocking(fd, FALSE);
size = read(fd, buffer, sizeof(af_byte_t) * count);
*again = size == -1 && (errno == EAGAIN || errno == EWOULDBLOCK ||
errno == EINTR) ? TRUE : FALSE;
*error = size != -1 || (size == -1 && (errno == EAGAIN ||
errno == EWOULDBLOCK ||
errno == EINTR)) ? 0 : errno;
return size;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movl %edi, %ebp
xorl %r13d, %r13d
xorl %esi, %esi
callq 0xbd84
movl %ebp, %edi
movq %r12, %rsi
movq %r14, %rdx
callq 0x21c0
movq %rax, %r14
cmpq $-0x1, %rax
je 0xce9e
movq $0x0, (%r15)
movl %r13d, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
movl (%rax), %eax
cmpl $0xb, %eax
sete %cl
cmpl $0x4, %eax
sete %dl
orb %cl, %dl
movzbl %dl, %ecx
negq %rcx
movq %rcx, (%r15)
cmpl $0x4, %eax
je 0xce89
cmpl $0xb, %eax
je 0xce89
movl %eax, %r13d
jmp 0xce89
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_write_nonblock
|
ssize_t af_io_write_nonblock(int fd, af_byte_t* buffer, af_io_size_t count,
af_bool_t* again, af_io_error_t* error) {
ssize_t size;
af_fd_set_blocking(fd, FALSE);
size = write(fd, buffer, sizeof(af_byte_t) * count);
*again = size == -1 && (errno == EAGAIN || errno == EWOULDBLOCK ||
errno == EINTR) ? TRUE : FALSE;
*error = size != -1 || (size == -1 && (errno == EAGAIN ||
errno == EWOULDBLOCK ||
errno == EINTR)) ? 0 : errno;
return size;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movl %edi, %ebp
xorl %r13d, %r13d
xorl %esi, %esi
callq 0xbd84
movl %ebp, %edi
movq %r12, %rsi
movq %r14, %rdx
callq 0x20f0
movq %rax, %r14
cmpq $-0x1, %rax
je 0xcf20
movq $0x0, (%r15)
movl %r13d, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
movl (%rax), %eax
cmpl $0xb, %eax
sete %cl
cmpl $0x4, %eax
sete %dl
orb %cl, %dl
movzbl %dl, %ecx
negq %rcx
movq %rcx, (%r15)
cmpl $0x4, %eax
je 0xcf0b
cmpl $0xb, %eax
je 0xcf0b
movl %eax, %r13d
jmp 0xcf0b
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
af_io_remove_done
|
void af_io_remove_done(af_io_t* io) {
af_io_action_t* first_new_action = NULL;
af_io_action_t* current_action = io->first_active_action;
while(current_action) {
af_io_action_t* next_action = current_action->next_action;
if(current_action->is_done) {
af_io_action_t* current_waiting_action = io->first_waiting_action;
af_bool_t found = FALSE;
if(current_action->type == AF_IO_TYPE_WRITE) {
io->pending_write_count--;
}
if(current_action->prev_action) {
current_action->prev_action->next_action =
current_action->next_action;
} else {
io->first_active_action = current_action->next_action;
}
if(current_action->next_action) {
current_action->next_action->prev_action =
current_action->prev_action;
}
if(!current_action->to_be_destroyed) {
current_action->prev_action = NULL;
current_action->next_action = io->first_done_action;
if(io->first_done_action) {
io->first_done_action->prev_action = current_action;
}
io->first_done_action = current_action;
}
while(current_waiting_action) {
if(current_waiting_action->fd == current_action->fd) {
found = TRUE;
break;
}
current_waiting_action = current_waiting_action->next_action;
}
if(found) {
if(current_waiting_action->prev_action) {
current_waiting_action->prev_action->next_action =
current_waiting_action->next_action;
} else {
io->first_waiting_action = current_waiting_action->next_action;
}
if(current_waiting_action->next_action) {
current_waiting_action->next_action->prev_action =
current_waiting_action->prev_action;
} else {
io->last_waiting_action = current_waiting_action->prev_action;
}
current_waiting_action->prev_action = NULL;
current_waiting_action->next_action = io->first_active_action;
if(current_waiting_action->next_action) {
current_waiting_action->next_action->prev_action =
current_waiting_action;
}
io->first_active_action = current_waiting_action;
} else {
io->active_action_count--;
}
if(current_action->task_to_wake) {
pthread_mutex_unlock(&io->mutex);
af_lock(io->global);
af_wake(io->global, current_action->task_to_wake);
if(io->handler_task) {
af_begin_atomic(io->global, io->handler_task);
}
af_unlock(io->global);
af_cond_signal(&io->global->cond);
pthread_mutex_lock(&io->mutex);
} else if(io->handler_task) {
pthread_mutex_unlock(&io->mutex);
af_lock(io->global);
if(io->handler_task) {
af_begin_atomic(io->global, io->handler_task);
}
af_unlock(io->global);
af_cond_signal(&io->global->cond);
pthread_mutex_lock(&io->mutex);
}
if(current_action->to_be_destroyed) {
if(current_action->is_buffer_freeable) {
free(current_action->buffer);
}
free(current_action);
}
}
current_action = next_action;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rdi), %r12
testq %r12, %r12
je 0xd120
movq %rdi, %rbx
leaq 0x58(%rdi), %r13
leaq 0x60(%rdi), %rbp
leaq 0x8(%rdi), %r14
movq %r12, %r15
movq 0x8(%r12), %r12
cmpq $0x0, 0x78(%r15)
je 0xd117
cmpq $0x1, 0x18(%r15)
jne 0xcfeb
decq 0x48(%rbx)
movq (%r13), %rax
movq (%r15), %rcx
testq %rcx, %rcx
je 0xd001
movq %r12, 0x8(%rcx)
movq 0x8(%r15), %rdx
jmp 0xd008
movq %r12, 0x50(%rbx)
movq %r12, %rdx
testq %rdx, %rdx
je 0xd010
movq %rcx, (%rdx)
cmpq $0x0, 0x20(%r15)
jne 0xd032
movq $0x0, (%r15)
movq 0x68(%rbx), %rcx
movq %rcx, 0x8(%r15)
testq %rcx, %rcx
je 0xd02e
movq %r15, (%rcx)
movq %r15, 0x68(%rbx)
testq %rax, %rax
je 0xd049
movl 0x28(%r15), %ecx
cmpl %ecx, 0x28(%rax)
je 0xd04f
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0xd03b
decq 0x40(%rbx)
jmp 0xd089
movq (%rax), %rcx
movq 0x8(%rax), %rdx
leaq 0x8(%rcx), %rsi
testq %rcx, %rcx
cmoveq %r13, %rsi
movq %rdx, (%rsi)
testq %rdx, %rdx
cmoveq %rbp, %rdx
movq %rcx, (%rdx)
movq $0x0, (%rax)
movq 0x50(%rbx), %rcx
movq %rcx, 0x8(%rax)
testq %rcx, %rcx
je 0xd085
movq %rax, (%rcx)
movq %rax, 0x50(%rbx)
cmpq $0x0, 0x70(%r15)
je 0xd0b0
movq %r14, %rdi
callq 0x2210
movq 0x30(%rbx), %rdi
callq 0x2db0
movq 0x30(%rbx), %rdi
movq 0x70(%r15), %rsi
callq 0x3291
jmp 0xd0c8
cmpq $0x0, 0x78(%rbx)
je 0xd0f8
movq %r14, %rdi
callq 0x2210
movq 0x30(%rbx), %rdi
callq 0x2db0
movq 0x78(%rbx), %rsi
testq %rsi, %rsi
je 0xd0da
movq 0x30(%rbx), %rdi
callq 0x32ad
movq 0x30(%rbx), %rdi
callq 0x2db9
movq 0x30(%rbx), %rdi
addq $0x20, %rdi
callq 0xbc9b
movq %r14, %rdi
callq 0x2310
cmpq $0x0, 0x20(%r15)
je 0xd117
cmpq $0x0, 0x68(%r15)
je 0xd10f
movq 0x30(%r15), %rdi
callq 0x2050
movq %r15, %rdi
callq 0x2050
testq %r12, %r12
jne 0xcfcd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
|
main
|
int main (int argc, char **argv) {
// local variables
t_24c16 eeprom;
t_eeprom_data data;
int exit_code=0;
int result;
int c;
int i;
char sn[7];
char zero[1]={0x00};
// usage message
const char* Usage = "\n"\
" -c calibrate sensors\n"\
" -s [serial] write serial number (6 characters)\n"\
" -i initialize EEPROM. All values will be cleared !!!\n"\
"\n";
// disable buffering
setbuf(stdout, NULL);
// print banner
printf("sensorcal V%c.%c RELEASE %c build: %s %s\n", VERSION_MAJOR, VERSION_MINOR, VERSION_RELEASE, __DATE__, __TIME__);
printf("sensorcal Copyright (C) 2014 see AUTHORS on www.openvario.org\n");
printf("This program comes with ABSOLUTELY NO WARRANTY;\n");
printf("This is free software, and you are welcome to redistribute it under certain conditions;\n");
// open eeprom object
result = eeprom_open(&eeprom, 0x50);
if (result != 0)
{
printf("No EEPROM found !!\n");
exit(1);
}
sn[6]=0;
// check commandline arguments
while ((c = getopt (argc, argv, "his:cde")) != -1)
{
switch (c) {
case 'h':
printf("Usage: sensorcal [OPTION]\n%s",Usage);
break;
case 'i':
printf("Initialize EEPROM ...\n");
for (i=0; i<128; i++)
{
result = eeprom_write(&eeprom, &zero[0], i, 1);
}
strcpy(data.header, "OV");
data.data_version = EEPROM_DATA_VERSION;
memset(data.serial,'0',6);
data.zero_offset=0.0;
update_checksum(&data);
printf("Writing data to EEPROM ...\n");
result = eeprom_write(&eeprom, (char*)&data, 0x00, sizeof(data));
break;
case 'c':
// read actual EEPROM values
printf("Reading EEPROM values ...\n\n");
if( eeprom_read_data(&eeprom, &data) == 0)
{
calibrate_ams5915(&data);
printf("New Offset: %f\n",(data.zero_offset));
update_checksum(&data);
printf("Writing data to EEPROM ...\n");
result = eeprom_write(&eeprom, (char*)&data, 0x00, sizeof(data));
}
else
{
printf("EEPROM content not valid !!\n");
printf("Please use -i to initialize EEPROM !!\n");
exit_code=2;
break;
}
break;
case 'e':
// delete complete EEPROM
printf("Delete whole EEPROM ...\n\n");
for (i=0; i< sizeof(data); i++)
{
result = eeprom_write(&eeprom, &zero[0], 0x00, 1);
}
printf("EEPROM cleared !!\n");
exit_code=3;
printf("End ...\n");
exit(exit_code);
break;
case 'd':
// read actual EEPROM values
printf("Reading EEPROM values ...\n\n");
if( eeprom_read_data(&eeprom, &data) == 0)
{
memcpy(sn,data.serial,6);
printf("Actual EEPROM values:\n");
printf("---------------------\n");
printf("Serial: \t\t\t%s\n", sn);
printf("Differential pressure offset:\t%f\n",data.zero_offset);
}
else
{
printf("EEPROM content not valid !!\n");
printf("Please use -i to initialize EEPROM !!\n");
exit_code=2;
break;
}
printf("End ...\n");
exit(exit_code);
break;
case 's':
if( strlen(optarg) == 6)
{
// read actual EEPROM values
if( eeprom_read_data(&eeprom, &data) == 0)
{
for(i=0; i<6;i++)
{
sn[i]=data.serial[i]=*optarg;
optarg++;
}
printf("New Serial number: %s\n",sn);
update_checksum(&data);
printf("Writing data to EEPROM ...\n");
result = eeprom_write(&eeprom, (char*)&data, 0x00, sizeof(data));
}
else
{
printf("EEPROM content not valid !!\n");
printf("Please use -i to initialize EEPROM !!\n");
exit_code=2;
break;
}
}
else
{
printf("ERROR: Serialnumber has to have exactly 6 characters !!\n");
exit_code=1;
break;
}
break;
case '?':
printf("Unknow option %c\n", optopt);
printf("Usage: sensorcal [OPTION]\n%s",Usage);
printf("Exiting ...\n");
}
}
printf("End ...\n");
return(exit_code);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movb $0x0, 0xb(%rsp)
movq 0x266d(%rip), %rax # 0x3fc8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1080
leaq 0x944(%rip), %rdi # 0x22b0
leaq 0x967(%rip), %r8 # 0x22da
leaq 0x96c(%rip), %r9 # 0x22e6
movl $0x30, %esi
movl $0x31, %edx
movl $0x31, %ecx
xorl %eax, %eax
callq 0x1090
leaq 0xa08(%rip), %rdi # 0x239f
callq 0x1040
leaq 0xa3b(%rip), %rdi # 0x23de
callq 0x1040
leaq 0xa5f(%rip), %rdi # 0x240e
callq 0x1040
leaq 0x30(%rsp), %rdi
movl $0x50, %esi
callq 0x1150
testl %eax, %eax
jne 0x1e23
leaq 0x24(%rsp), %rax
movb $0x0, 0x6(%rax)
leaq 0x914(%rip), %r15 # 0x22ef
leaq 0x30(%rsp), %r12
leaq 0xb3d(%rip), %r14 # 0x2524
leaq 0xb(%rsp), %r13
movl $0x0, 0xc(%rsp)
movq %rbx, 0x38(%rsp)
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x10e0
cmpl $0x62, %eax
jle 0x1a87
leal -0x63(%rax), %ecx
cmpl $0x6, %ecx
ja 0x1acd
leaq 0x7d6(%rip), %rdx # 0x21f4
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0xadb(%rip), %rdi # 0x2509
callq 0x1040
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
callq 0x162a
testl %eax, %eax
jne 0x1b85
leaq 0x932(%rip), %rdi # 0x2381
xorl %eax, %eax
callq 0x1090
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0x28, %esi
callq 0x1758
testl %eax, %eax
je 0x1c54
leaq 0xb3d(%rip), %rdi # 0x25b4
callq 0x1040
movss 0x1c(%rsp), %xmm1
jmp 0x1cfa
cmpl $0x3f, %eax
jne 0x1c2d
movq 0x2549(%rip), %rax # 0x3fe0
movl (%rax), %esi
leaq 0x8cf(%rip), %rdi # 0x236f
xorl %eax, %eax
callq 0x1090
leaq 0x849(%rip), %rdi # 0x22f7
leaq 0x75b(%rip), %rsi # 0x2210
xorl %eax, %eax
callq 0x1090
leaq 0x9a3(%rip), %rdi # 0x2466
callq 0x1040
jmp 0x19f9
cmpl $0x73, %eax
jne 0x19f9
movq 0x24f3(%rip), %rax # 0x3fd0
movq (%rax), %rdi
callq 0x1070
cmpq $0x6, %rax
jne 0x1c3b
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
callq 0x162a
testl %eax, %eax
jne 0x1b85
movq 0x24c5(%rip), %rdi # 0x3fd0
movq (%rdi), %rax
leaq 0x1(%rax), %rcx
xorl %edx, %edx
movb (%rax,%rdx), %sil
movb %sil, 0x14(%rsp,%rdx)
movb %sil, 0x24(%rsp,%rdx)
leaq (%rcx,%rdx), %rsi
movq %rsi, (%rdi)
incq %rdx
cmpq $0x6, %rdx
jne 0x1b14
leaq 0x81f(%rip), %rdi # 0x2358
leaq 0x24(%rsp), %rsi
xorl %eax, %eax
callq 0x1090
jmp 0x1d0f
leaq 0x7a6(%rip), %rdi # 0x22f7
leaq 0x6b8(%rip), %rsi # 0x2210
xorl %eax, %eax
callq 0x1090
jmp 0x19f9
leaq 0x99e(%rip), %rdi # 0x2509
callq 0x1040
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
callq 0x162a
testl %eax, %eax
je 0x1d65
movq %r14, %rdi
callq 0x1040
leaq 0x9ac(%rip), %rdi # 0x2540
callq 0x1040
movl $0x2, 0xc(%rsp)
jmp 0x19f9
leaq 0x9b9(%rip), %rdi # 0x2566
callq 0x1040
xorl %r15d, %r15d
movzbl %r15b, %edx
movq %r12, %rdi
movq %r13, %rsi
movl $0x1, %ecx
callq 0x16dc
incl %r15d
cmpl $0x80, %r15d
jne 0x1bb5
movl $0x100564f, 0x10(%rsp) # imm = 0x100564F
leaq 0x14(%rsp), %rax
movw $0x3030, 0x4(%rax) # imm = 0x3030
movl $0x30303030, (%rax) # imm = 0x30303030
movl $0x0, 0x1c(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x1614
leaq 0x972(%rip), %rdi # 0x257c
callq 0x1040
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl $0x14, %ecx
callq 0x16dc
leaq 0x6c7(%rip), %r15 # 0x22ef
jmp 0x19f9
cmpl $-0x1, %eax
jne 0x19f9
jmp 0x1d46
leaq 0x830(%rip), %rdi # 0x2472
callq 0x1040
movl $0x1, 0xc(%rsp)
jmp 0x19f9
leaq 0x94f(%rip), %rdi # 0x25aa
callq 0x1040
movss 0x580(%rip), %xmm0 # 0x21e8
movlps %xmm0, 0x5c(%rsp)
movq %r14, %rdi
callq 0x17e6
movl $0x1b774, %edi # imm = 0x1B774
callq 0x1130
callq 0x151c
xorps %xmm1, %xmm1
movl $0x320, %r15d # imm = 0x320
leaq 0x6fd(%rip), %rbx # 0x2391
movss %xmm1, 0x2c(%rsp)
movss 0x54a(%rip), %xmm0 # 0x21ec
callq 0x152d
movq %r14, %rdi
callq 0x1815
callq 0x151c
movq %r14, %rdi
callq 0x18a7
xorps %xmm0, %xmm0
cvtss2sd 0x58(%rsp), %xmm0
movq %rbx, %rdi
movb $0x1, %al
callq 0x1090
movss 0x2c(%rsp), %xmm1
addss 0x58(%rsp), %xmm1
decl %r15d
jne 0x1c94
divss 0x508(%rip), %xmm1 # 0x21f0
movss %xmm1, 0x1c(%rsp)
leaq 0x5fa(%rip), %r15 # 0x22ef
movq 0x38(%rsp), %rbx
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x60f(%rip), %rdi # 0x2317
movb $0x1, %al
callq 0x1090
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1614
leaq 0x859(%rip), %rdi # 0x257c
callq 0x1040
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x14, %ecx
callq 0x16dc
leaq 0x7e3(%rip), %r14 # 0x2524
jmp 0x19f9
leaq 0x7b4(%rip), %rdi # 0x2501
callq 0x1040
movl 0xc(%rsp), %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14(%rsp), %rcx
movzwl 0x4(%rcx), %eax
leaq 0x24(%rsp), %rbx
movw %ax, 0x4(%rbx)
movl (%rcx), %eax
movl %eax, (%rbx)
leaq 0x728(%rip), %rdi # 0x24aa
callq 0x1040
leaq 0x732(%rip), %rdi # 0x24c0
callq 0x1040
leaq 0x58d(%rip), %rdi # 0x2327
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1090
xorps %xmm0, %xmm0
cvtss2sd 0x1c(%rsp), %xmm0
leaq 0x582(%rip), %rdi # 0x2336
movb $0x1, %al
callq 0x1090
leaq 0x73f(%rip), %rdi # 0x2501
callq 0x1040
movl 0xc(%rsp), %edi
callq 0x10f0
leaq 0x6ff(%rip), %rdi # 0x24d6
callq 0x1040
movl $0x14, %ebp
leaq 0x30(%rsp), %rbx
leaq 0xb(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x16dc
decl %ebp
jne 0x1deb
leaq 0x6e7(%rip), %rdi # 0x24ef
callq 0x1040
leaq 0x6ed(%rip), %rdi # 0x2501
callq 0x1040
movl $0x3, %edi
callq 0x10f0
leaq 0x76d(%rip), %rdi # 0x2597
callq 0x1040
movl $0x1, %edi
callq 0x10f0
nopl (%rax)
|
/workspace/github_c_makefile_star2_O3/Openvario[P]sensord/sensorcal.c
|
main
|
int main(int argc, char *argv[])
{
file_node_t *root;
char *root_dir;
FILE *fh;
if (argc < 2) {
fprintf(stderr, "Usage: %s <output file> [directory]\n", argv[0]);
return 1;
}
fh = fopen(argv[1], "wx");
if (fh == NULL) {
fprintf(stderr, "Error: Cannot open file, or it exists already: %s\n", argv[1]);
return 1;
}
if (argc > 2) {
root_dir = argv[2];
} else {
root_dir = ".";
}
root = file_node_new(NULL, NULL, FILE_NODE_TYPE_ROOT);
if (root == NULL) {
fclose(fh);
return 1;
}
if (file_node_scan(root, root_dir) != 0) {
file_node_remove(root);
fclose(fh);
return 1;
}
file_node_sort(root);
if (isatty(STDOUT_FILENO)) {
file_node_curses_loop(root);
file_node_print_marked(root, root_dir, fh);
} else {
/* Mostly for debugging. */
file_node_dump(root);
}
file_node_remove(root);
fclose(fh);
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
cmpl $0x1, %edi
jle 0x16ad
movl %edi, %ebp
movq 0x8(%r14), %rdi
leaq 0xc96(%rip), %rsi # 0x2029
callq 0x11b0
testq %rax, %rax
je 0x16ba
movq %rax, %rbx
cmpl $0x2, %ebp
jne 0x13b2
leaq 0xcaf(%rip), %r15 # 0x205f
jmp 0x13b6
movq 0x10(%r14), %r15
movl $0x30, %edi
callq 0x1190
testq %rax, %rax
je 0x13f8
movq %rax, %r14
xorl %eax, %eax
movq %rax, 0x8(%r14)
movl %eax, 0x10(%r14)
movq %rax, 0x18(%r14)
movl %eax, 0x20(%r14)
movq %rax, 0x28(%r14)
movl %eax, (%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1751
testl %eax, %eax
je 0x140a
movq %r14, %rdi
callq 0x188a
movq %rbx, %rdi
callq 0x10b0
movl $0x1, %eax
jmp 0x169e
movq %r14, %rdi
callq 0x18d8
movl $0x1, %edi
callq 0x1090
testl %eax, %eax
je 0x1684
movq %r15, 0x10(%rsp)
callq 0x1110
leaq 0x65e(%rip), %rdi # 0x1a93
callq 0x1f80
callq 0x10e0
movq 0x2b92(%rip), %r13 # 0x3fd8
movq (%r13), %rdi
movl $0x1, %esi
callq 0x1130
leaq 0xc(%rsp), %r12
movq %r14, %rdi
callq 0x1a98
movl %eax, %ebp
movq %r14, %rdi
callq 0x1ada
movq (%r13), %rdi
testq %rdi, %rdi
je 0x147e
movswl 0x4(%rdi), %r15d
incl %r15d
jmp 0x1484
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
callq 0x10a0
cmpl $0x14a, %eax # imm = 0x14A
jg 0x14b2
cmpl $0x50, %eax
jg 0x14fb
cmpl $0x1a, %eax
jg 0x1575
cmpl $0xa, %eax
je 0x15ae
cmpl $0xd, %eax
je 0x15ae
jmp 0x1459
cmpl $0x152, %eax # imm = 0x152
jle 0x1523
cmpl $0x153, %eax # imm = 0x153
je 0x162b
cmpl $0x157, %eax # imm = 0x157
je 0x15ae
cmpl $0x19a, %eax # imm = 0x19A
jne 0x1459
callq 0x1200
movq %r14, %rdi
callq 0x1ada
callq 0x1060
movq (%r13), %rdi
movl $0x1, %esi
callq 0x1130
jmp 0x1459
cmpl $0x102, %eax # imm = 0x102
jg 0x15e5
je 0x15ae
cmpl $0x51, %eax
je 0x1672
cmpl $0x71, %eax
jne 0x1459
jmp 0x1672
cmpl $0x14b, %eax # imm = 0x14B
je 0x157e
cmpl $0x152, %eax # imm = 0x152
jne 0x1459
movl %r15d, %eax
shrl $0x1f, %eax
addl %r15d, %eax
sarl %eax
addl %r15d, %eax
addl 0x2be7(%rip), %eax # 0x4130
cmpl %eax, %ebp
jl 0x154f
movl %eax, %ebp
subl %r15d, %ebp
testl %ebp, %ebp
jg 0x1558
xorl %ebp, %ebp
movl %ebp, 0x2bd2(%rip) # 0x4130
cmpl %ebp, 0x2bc8(%rip) # 0x412c
jge 0x1459
movl %ebp, 0x2bbc(%rip) # 0x412c
jmp 0x1459
cmpl $0x20, %eax
jne 0x1669
movl 0x2ba8(%rip), %esi # 0x412c
incl %esi
movl $0x0, 0xc(%rsp)
movq %r14, %rdi
movq %r12, %rdx
callq 0x1e8e
testq %rax, %rax
je 0x15ae
cmpl $0x2, 0x10(%rax)
jne 0x15ae
xorl %ecx, %ecx
cmpl $0x0, (%rax)
sete %cl
movl %ecx, (%rax)
movl 0x2b78(%rip), %eax # 0x412c
leal 0x1(%rax), %ecx
cmpl %ebp, %ecx
cmovll %ecx, %eax
movl %eax, 0x2b6a(%rip) # 0x412c
subl %r15d, %eax
jl 0x1459
movl 0x2b5f(%rip), %ecx # 0x4130
xorl %edx, %edx
cmpl %eax, %ecx
setle %dl
addl %ecx, %edx
movl %edx, 0x2b50(%rip) # 0x4130
jmp 0x1459
cmpl $0x103, %eax # imm = 0x103
jne 0x1459
movl 0x2b36(%rip), %ecx # 0x412c
xorl %eax, %eax
testl %ecx, %ecx
setg %al
subl %eax, %ecx
movl %ecx, 0x2b27(%rip) # 0x412c
movl 0x2b25(%rip), %eax # 0x4130
cmpl %ecx, %eax
jle 0x1459
cmpl $0x2, %eax
movl $0x1, %ecx
cmovll %ecx, %eax
decl %eax
movl %eax, 0x2b0a(%rip) # 0x4130
jmp 0x1459
movl %r15d, %ecx
shrl $0x1f, %ecx
addl %r15d, %ecx
sarl %ecx
movl 0x2af4(%rip), %eax # 0x4130
subl %ecx, %eax
testl %eax, %eax
jg 0x1644
xorl %eax, %eax
movl %eax, 0x2ae6(%rip) # 0x4130
addl %eax, %r15d
cmpl %r15d, 0x2ad8(%rip) # 0x412c
jl 0x1459
decl %r15d
movl %r15d, 0x2ac8(%rip) # 0x412c
jmp 0x1459
cmpl $0x1b, %eax
jne 0x1459
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x1920
jmp 0x168c
movq %r14, %rdi
callq 0x1999
movq %r14, %rdi
callq 0x188a
movq %rbx, %rdi
callq 0x10b0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x125e
jmp 0x1400
addq $0x8, %r14
movq %r14, %rdi
callq 0x1240
jmp 0x1400
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
file_node_new
|
static file_node_t *file_node_new(file_node_t *parent, char *name, file_node_type_t type)
{
int len;
file_node_t *new;
new = (file_node_t *)malloc(sizeof(file_node_t));
if (new == NULL)
return NULL;
if (name == NULL) {
new->name = NULL;
} else {
len = strlen(name) + 1;
new->name = (char *)malloc(len);
strncpy(new->name, name, len);
}
new->type = type;
new->parent = parent;
new->no_of_subnodes = 0;
new->subnode = NULL;
new->marked = 0;
return new;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r15
movl $0x30, %edi
callq 0x1190
movq %rax, %r14
testq %rax, %rax
je 0x173f
xorl %eax, %eax
testq %r12, %r12
je 0x1721
movq %r12, %rdi
callq 0x10d0
incl %eax
movslq %eax, %rbp
movq %rbp, %rdi
callq 0x1190
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1070
xorl %eax, %eax
jmp 0x1724
xorl %r13d, %r13d
movq %r13, 0x8(%r14)
movl %ebx, 0x10(%r14)
movq %r15, 0x18(%r14)
movl %eax, 0x20(%r14)
movq $0x0, 0x28(%r14)
movl %eax, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
file_node_scan
|
static int file_node_scan(file_node_t *current, char *path)
{
DIR *dh;
struct dirent *entry;
struct stat st;
char fullpath[PATH_MAX];
file_node_t *subnode;
dh = opendir(path);
if (dh == NULL) {
fprintf(stderr, "Error: Unable to open directory: %s\n", path);
return -1;
}
while ((entry = readdir(dh))) {
if (entry->d_name[0] == '.')
continue; /* Ignore files with leading dot. */
snprintf(fullpath, PATH_MAX, "%s/%s", path, entry->d_name);
if (stat(fullpath, &st) == -1) {
fprintf(stderr, "Warning: Unable to stat() path: %s\n", fullpath);
continue;
}
if (S_ISDIR(st.st_mode)) {
subnode = file_node_add(current, entry->d_name, FILE_NODE_TYPE_DIR);
file_node_scan(subnode, fullpath);
} else if (S_ISREG(st.st_mode)) {
file_node_add(current, entry->d_name, FILE_NODE_TYPE_FILE);
}
}
closedir(dh);
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1098, %rsp # imm = 0x1098
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x10c0
testq %rax, %rax
je 0x1868
movq %rax, %r15
movq %rax, %rdi
callq 0x1180
testq %rax, %rax
je 0x184c
movq %rax, %r12
leaq 0x90(%rsp), %r13
movq %rsp, %rbp
cmpb $0x2e, 0x13(%r12)
je 0x1819
addq $0x13, %r12
movl $0x1000, %esi # imm = 0x1000
movq %r13, %rdi
leaq 0x8d0(%rip), %rdx # 0x2086
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x1100
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1170
cmpl $-0x1, %eax
je 0x182f
movl 0x18(%rsp), %eax
movl $0xf000, %ecx # imm = 0xF000
andl %ecx, %eax
movl %eax, %ecx
negw %cx
jo 0x1809
cmpl $0x4000, %eax # imm = 0x4000
jne 0x1819
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x1a2d
movq %rax, %rdi
movq %r13, %rsi
callq 0x1751
jmp 0x1819
movq %r14, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x1a2d
movq %r15, %rdi
callq 0x1180
movq %rax, %r12
testq %rax, %rax
jne 0x179b
jmp 0x184c
movq 0x27c2(%rip), %rax # 0x3ff8
movq (%rax), %rdi
leaq 0x84c(%rip), %rsi # 0x208c
movq %r13, %rdx
xorl %eax, %eax
callq 0x1160
jmp 0x1819
movq %r15, %rdi
callq 0x1120
xorl %eax, %eax
addq $0x1098, %rsp # imm = 0x1098
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2789(%rip), %rax # 0x3ff8
movq (%rax), %rdi
leaq 0x7e8(%rip), %rsi # 0x2061
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1160
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x1856
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
file_node_remove
|
static void file_node_remove(file_node_t *node)
{
int i;
free(node->name);
for (i = 0; i < node->no_of_subnodes; i++) {
file_node_remove(node->subnode[i]);
}
if (node->subnode != NULL) {
free(node->subnode);
}
free(node);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1040
cmpl $0x0, 0x20(%rbx)
je 0x18bb
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x188a
incq %r14
movl 0x20(%rbx), %eax
cmpq %rax, %r14
jb 0x18a3
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x18c9
callq 0x1040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
file_node_sort
|
static void file_node_sort(file_node_t *node)
{
int i;
qsort(node->subnode, node->no_of_subnodes, sizeof(file_node_t *), file_node_compare);
for (i = 0; i < node->no_of_subnodes; i++) {
file_node_sort(node->subnode[i]);
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movl 0x20(%rbx), %esi
leaq 0x193(%rip), %rcx # 0x1a80
movl $0x8, %edx
callq 0x1080
cmpl $0x0, 0x20(%rbx)
je 0x1918
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x18d8
incq %r14
movl 0x20(%rbx), %eax
cmpq %rax, %r14
jb 0x1900
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
file_node_print_marked
|
static void file_node_print_marked(file_node_t *node, char *root_dir, FILE *fh)
{
int i;
char path[PATH_MAX];
if (node->marked) {
fprintf(fh, "%s/%s\n", root_dir, file_node_path(node, path, PATH_MAX));
}
for (i = 0; i < node->no_of_subnodes; i++) {
file_node_print_marked(node->subnode[i], root_dir, fh);
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp # imm = 0x1008
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, (%rdi)
je 0x1961
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1eee
leaq 0x75f(%rip), %rsi # 0x20b0
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x1160
cmpl $0x0, 0x20(%r15)
je 0x198a
xorl %r12d, %r12d
movq 0x28(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1920
incq %r12
movl 0x20(%r15), %eax
cmpq %rax, %r12
jb 0x196b
addq $0x1008, %rsp # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
file_node_dump
|
static void file_node_dump(file_node_t *node)
{
int i, depth;
depth = file_node_depth(node);
while (depth-- > 1)
printf(" ");
if (node->type == FILE_NODE_TYPE_ROOT)
printf("/");
else {
printf("%s", node->name);
if (node->type == FILE_NODE_TYPE_DIR)
printf("/");
}
printf("\n");
for (i = 0; i < node->no_of_subnodes; i++) {
file_node_dump(node->subnode[i]);
}
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rdi, %rax
cmpl $0x0, 0x10(%rax)
je 0x19b6
movq 0x18(%rax), %rax
incl %ebp
testq %rax, %rax
jne 0x19a5
cmpl $0x2, %ebp
jl 0x19d5
incl %ebp
leaq 0x6f3(%rip), %r14 # 0x20b7
movq %r14, %rdi
xorl %eax, %eax
callq 0x10f0
decl %ebp
cmpl $0x2, %ebp
ja 0x19c4
cmpl $0x0, 0x10(%rbx)
je 0x19f3
movq 0x8(%rbx), %rsi
leaq 0x6a3(%rip), %rdi # 0x2089
xorl %eax, %eax
callq 0x10f0
cmpl $0x1, 0x10(%rbx)
jne 0x19fd
movl $0x2f, %edi
callq 0x1050
movl $0xa, %edi
callq 0x1050
cmpl $0x0, 0x20(%rbx)
je 0x1a28
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1999
incq %r14
movl 0x20(%rbx), %eax
cmpq %rax, %r14
jb 0x1a10
popq %rbx
popq %r14
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
file_node_add
|
static file_node_t *file_node_add(file_node_t *current, char *name, file_node_type_t type)
{
file_node_t *new;
new = file_node_new(current, name, type);
if (new == NULL)
return NULL;
if (current->subnode == NULL) {
current->subnode = malloc(sizeof(file_node_t *));
} else {
current->subnode = realloc(current->subnode, sizeof(file_node_t *) * (current->no_of_subnodes + 1));
}
current->subnode[current->no_of_subnodes] = new;
current->no_of_subnodes++;
return new;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x16cb
movq %rax, %r14
testq %rax, %rax
je 0x1a75
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x1a5a
movl 0x20(%rbx), %esi
incl %esi
shlq $0x3, %rsi
callq 0x11a0
jmp 0x1a64
movl $0x8, %edi
callq 0x1190
movq %rax, 0x28(%rbx)
movl 0x20(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x20(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
file_node_list_size
|
static int file_node_list_size(file_node_t *node)
{
int i, size;
if (node->type == FILE_NODE_TYPE_ROOT) {
size = 0;
} else {
size = 1;
}
for (i = 0; i < node->no_of_subnodes; i++) {
size += file_node_list_size(node->subnode[i]);
}
return size;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpl $0x0, 0x10(%rdi)
setne %bl
movl 0x20(%rdi), %r14d
testq %r14, %r14
je 0x1acc
movq 0x28(%rdi), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x1a98
addl %eax, %ebx
incq %r12
cmpq %r12, %r14
jne 0x1ab9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
curses_update_screen
|
static void curses_update_screen(file_node_t *node)
{
int n, i, maxy, maxx;
int scrollbar_size, scrollbar_pos;
int list_size;
list_size = file_node_list_size(node);
getmaxyx(stdscr, maxy, maxx);
erase();
/* Draw text lines. */
for (n = 0; n < maxy; n++) {
if ((n + curses_scroll_offset) >= list_size)
break;
if (n == (curses_selected_entry - curses_scroll_offset)) {
curses_list_draw(node, n, n + curses_scroll_offset + 1, 1);
} else {
curses_list_draw(node, n, n + curses_scroll_offset + 1, 0);
}
}
/* Draw scrollbar. */
if (list_size <= maxy)
scrollbar_size = maxy;
else
scrollbar_size = maxy / (list_size / (double)maxy);
scrollbar_pos = curses_selected_entry / (double)list_size * (maxy - scrollbar_size);
attron(A_REVERSE);
for (i = 0; i <= scrollbar_size; i++)
mvaddch(i + scrollbar_pos, maxx - 1, ' ');
attroff(A_REVERSE);
mvvline(0, maxx - 2, 0, maxy);
/* Place cursor at end of selected line. */
move(curses_selected_entry - curses_scroll_offset, maxx - 3);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
callq 0x1a98
movl %eax, %r14d
movq 0x24de(%rip), %r13 # 0x3fd8
movq (%r13), %rdi
testq %rdi, %rdi
je 0x1b5a
movswl 0x4(%rdi), %r12d
leal 0x1(%r12), %ebp
movswl 0x6(%rdi), %ebx
incl %ebx
callq 0x1030
testl %r12d, %r12d
js 0x1b69
xorl %r12d, %r12d
movl 0x260a(%rip), %eax # 0x4130
leal (%r12,%rax), %ecx
cmpl %r14d, %ecx
jge 0x1b69
movl 0x25f7(%rip), %edx # 0x412c
subl %eax, %edx
xorl %ecx, %ecx
cmpl %edx, %r12d
sete %cl
leal (%r12,%rax), %edx
incl %edx
movq %r15, %rdi
movl %r12d, %esi
callq 0x1c6a
incl %r12d
cmpl %r12d, %ebp
jne 0x1b20
jmp 0x1b69
callq 0x1030
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl %ebp, %r14d
jle 0x1b8c
cvtsi2sd %ebp, %xmm0
cvtsi2sd %r14d, %xmm1
movsd %xmm1, 0x8(%rsp)
divsd %xmm0, %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %r12d
jmp 0x1b9a
cvtsi2sd %r14d, %xmm0
movsd %xmm0, 0x8(%rsp)
movl %ebp, %r12d
xorps %xmm0, %xmm0
cvtsi2sdl 0x2587(%rip), %xmm0 # 0x412c
movsd %xmm0, 0x10(%rsp)
movq (%r13), %rdi
movl $0x40000, %esi # imm = 0x40000
xorl %edx, %edx
callq 0x1140
testl %r12d, %r12d
js 0x1c12
movsd 0x10(%rsp), %xmm1
divsd 0x8(%rsp), %xmm1
movl %ebp, %eax
subl %r12d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %r14d
leal -0x1(%rbx), %r15d
incl %r12d
movq (%r13), %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x11d0
cmpl $-0x1, %eax
je 0x1c0a
movq (%r13), %rdi
movl $0x20, %esi
callq 0x11f0
incl %r14d
decl %r12d
jne 0x1be8
movq (%r13), %rdi
movl $0x40000, %esi # imm = 0x40000
xorl %edx, %edx
callq 0x1220
movq (%r13), %rdi
leal -0x2(%rbx), %edx
xorl %esi, %esi
callq 0x11d0
cmpl $-0x1, %eax
je 0x1c42
movq (%r13), %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x11c0
movq (%r13), %rdi
movl 0x24e0(%rip), %esi # 0x412c
subl 0x24de(%rip), %esi # 0x4130
addl $-0x3, %ebx
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11d0
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
curses_list_draw
|
static void curses_list_draw(file_node_t *node, int line_no, int node_no, int selected)
{
int node_count, maxy, maxx, pos, depth;
file_node_t *found;
node_count = 0;
found = file_node_get_by_node_no(node, node_no, &node_count);
if (found == NULL)
return;
getmaxyx(stdscr, maxy, maxx);
if (selected)
attron(A_REVERSE);
if (found->name == NULL) {
for (pos = 0; pos < maxx - 2; pos++)
mvaddch(line_no, pos, ' ');
} else {
pos = 0;
/* Depth indicator. */
depth = file_node_depth(found);
while (depth-- > 1) {
mvaddch(line_no, pos++, ' ');
mvaddch(line_no, pos++, ' ');
}
/* File/directory name. */
if (found->marked)
attron(A_BOLD);
mvaddstr(line_no, pos, found->name);
pos += strlen(found->name);
if (found->marked)
attroff(A_BOLD);
/* Slash for directory. */
if (found->type == FILE_NODE_TYPE_DIR)
mvaddch(line_no, pos++, '/');
/* Padding. */
for (; pos < maxx - 2; pos++)
mvaddch(line_no, pos, ' ');
}
if (selected)
attroff(A_REVERSE);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movl %esi, %ebp
leaq 0x14(%rsp), %rax
movl $0x0, (%rax)
movl %edx, %esi
movq %rax, %rdx
callq 0x1e8e
testq %rax, %rax
je 0x1e7f
movq %rax, %r14
movq 0x2333(%rip), %r13 # 0x3fd8
movq (%r13), %rdi
testq %rdi, %rdi
je 0x1cb6
movswl 0x6(%rdi), %ebx
decl %ebx
jmp 0x1cbb
movl $0xfffffffd, %ebx # imm = 0xFFFFFFFD
testl %r15d, %r15d
je 0x1ccc
movl $0x40000, %esi # imm = 0x40000
xorl %edx, %edx
callq 0x1140
cmpq $0x0, 0x8(%r14)
je 0x1df4
movq %r14, %rax
xorl %r14d, %r14d
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x10(%rax)
je 0x1cf4
movq 0x18(%rax), %rax
incl %r14d
testq %rax, %rax
jne 0x1ce2
movl %r15d, 0x4(%rsp)
xorl %r15d, %r15d
cmpl $0x2, %r14d
jl 0x1d61
incl %r14d
xorl %r12d, %r12d
movl %r12d, %r15d
movq (%r13), %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x11d0
cmpl $-0x1, %eax
je 0x1d2c
movq (%r13), %rdi
movl $0x20, %esi
callq 0x11f0
movq (%r13), %rdi
leal 0x1(%r15), %r12d
movl %ebp, %esi
movl %r12d, %edx
callq 0x11d0
cmpl $-0x1, %eax
je 0x1d51
movq (%r13), %rdi
movl $0x20, %esi
callq 0x11f0
decl %r14d
incl %r12d
cmpl $0x2, %r14d
ja 0x1d08
addl $0x2, %r15d
movq 0x8(%rsp), %r14
cmpl $0x0, (%r14)
movq (%r13), %rdi
je 0x1d80
movl $0x200000, %esi # imm = 0x200000
xorl %edx, %edx
callq 0x1140
movq (%r13), %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x11d0
cmpl $-0x1, %eax
je 0x1da1
movq (%r13), %rdi
movq 0x8(%r14), %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x1210
movq 0x8(%r14), %rdi
callq 0x10d0
movq %rax, %r12
cmpl $0x0, (%r14)
je 0x1dc3
movq (%r13), %rdi
movl $0x200000, %esi # imm = 0x200000
xorl %edx, %edx
callq 0x1220
addl %r12d, %r15d
cmpl $0x1, 0x10(%r14)
jne 0x1e26
movq (%r13), %rdi
leal 0x1(%r15), %r14d
movl %ebp, %esi
movl %r15d, %edx
callq 0x11d0
cmpl $-0x1, %eax
je 0x1e29
movq (%r13), %rdi
movl $0x2f, %esi
callq 0x11f0
jmp 0x1e29
testl %ebx, %ebx
jle 0x1e5c
xorl %r14d, %r14d
movq (%r13), %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x11d0
cmpl $-0x1, %eax
je 0x1e1c
movq (%r13), %rdi
movl $0x20, %esi
callq 0x11f0
incl %r14d
cmpl %r14d, %ebx
jne 0x1dfb
jmp 0x1e5c
movl %r15d, %r14d
movl 0x4(%rsp), %r15d
cmpl %ebx, %r14d
jge 0x1e5c
movq (%r13), %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x11d0
cmpl $-0x1, %eax
je 0x1e54
movq (%r13), %rdi
movl $0x20, %esi
callq 0x11f0
incl %r14d
cmpl %r14d, %ebx
jne 0x1e33
testl %r15d, %r15d
je 0x1e7f
movq (%r13), %rdi
movl $0x40000, %esi # imm = 0x40000
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1220
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
file_node_get_by_node_no
|
static file_node_t *file_node_get_by_node_no(file_node_t *node, int node_no, int *node_count)
{
file_node_t *found;
int i;
if (node->type != FILE_NODE_TYPE_ROOT) {
*node_count = *node_count + 1;
}
if (*node_count == node_no) {
return node; /* Match found, return self. */
}
for (i = 0; i < node->no_of_subnodes; i++) {
found = file_node_get_by_node_no(node->subnode[i], node_no, node_count);
if (found != NULL) {
return found;
}
}
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
movl (%rdx), %eax
je 0x1eaa
incl %eax
movl %eax, (%r14)
cmpl %ebp, %eax
je 0x1ee0
cmpl $0x0, 0x20(%rbx)
je 0x1ed9
xorl %r15d, %r15d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x1e8e
testq %rax, %rax
jne 0x1edd
incq %r15
movl 0x20(%rbx), %eax
cmpq %rax, %r15
jb 0x1eb7
xorl %ebx, %ebx
jmp 0x1ee0
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
file_node_path
|
static char *file_node_path(file_node_t *node, char *path, int path_len)
{
char temp[PATH_MAX];
strncpy(path, node->name, path_len);
node = node->parent;
while (node != NULL) {
if (node->type == FILE_NODE_TYPE_ROOT) {
break;
}
strncpy(temp, path, PATH_MAX);
snprintf(path, path_len, "%s/%s", node->name, temp);
node = node->parent;
}
return path;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp # imm = 0x1008
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
movl $0x1000, %edx # imm = 0x1000
movq %rbx, %rdi
callq 0x1070
movq 0x18(%r14), %r12
testq %r12, %r12
je 0x1f62
movq %rsp, %r14
leaq 0x160(%rip), %r15 # 0x2086
cmpl $0x0, 0x10(%r12)
je 0x1f62
movl $0x1000, %edx # imm = 0x1000
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1070
movq 0x8(%r12), %rcx
movl $0x1000, %esi # imm = 0x1000
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %r8
xorl %eax, %eax
callq 0x1100
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x1f26
movq %rbx, %rax
addq $0x1008, %rsp # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopw %cs:(%rax,%rax)
nop
|
/workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
|
main
|
int main(int argc, char **argv) {
FILE *f;
char st1[max_size];
char *bestw[N];
char file_name[max_size], st[100][max_size];
float dist, len, bestd[N], vec[max_size];
long long words, size, a, b, c, d, cn, bi[100];
char ch;
float *M;
char *vocab;
if (argc < 2) {
printf("Usage: ./distance <FILE>\nwhere FILE contains word projections in the BINARY FORMAT\n");
return 0;
}
strcpy(file_name, argv[1]);
f = fopen(file_name, "rb");
if (f == NULL) {
printf("Input file not found\n");
return -1;
}
fscanf(f, "%lld", &words);
fscanf(f, "%lld", &size);
vocab = (char *)malloc((long long)words * max_w * sizeof(char));
for (a = 0; a < N; a++) bestw[a] = (char *)malloc(max_size * sizeof(char));
M = (float *)malloc((long long)words * (long long)size * sizeof(float));
if (M == NULL) {
printf("Cannot allocate memory: %lld MB %lld %lld\n", (long long)words * size * sizeof(float) / 1048576, words, size);
return -1;
}
for (b = 0; b < words; b++) {
a = 0;
while (1) {
vocab[b * max_w + a] = fgetc(f);
if (feof(f) || (vocab[b * max_w + a] == ' ')) break;
if ((a < max_w) && (vocab[b * max_w + a] != '\n')) a++;
}
vocab[b * max_w + a] = 0;
for (a = 0; a < size; a++) fread(&M[a + b * size], sizeof(float), 1, f);
len = 0;
for (a = 0; a < size; a++) len += M[a + b * size] * M[a + b * size];
len = sqrt(len);
for (a = 0; a < size; a++) M[a + b * size] /= len;
}
fclose(f);
while (1) {
for (a = 0; a < N; a++) bestd[a] = 0;
for (a = 0; a < N; a++) bestw[a][0] = 0;
printf("Enter word or sentence (EXIT to break): ");
a = 0;
while (1) {
st1[a] = fgetc(stdin);
if ((st1[a] == '\n') || (a >= max_size - 1)) {
st1[a] = 0;
break;
}
a++;
}
if (!strcmp(st1, "EXIT")) break;
cn = 0;
b = 0;
c = 0;
while (1) {
st[cn][b] = st1[c];
b++;
c++;
st[cn][b] = 0;
if (st1[c] == 0) break;
if (st1[c] == ' ') {
cn++;
b = 0;
c++;
}
}
cn++;
for (a = 0; a < cn; a++) {
for (b = 0; b < words; b++) if (!strcmp(&vocab[b * max_w], st[a])) break;
if (b == words) b = -1;
bi[a] = b;
printf("\nWord: %s Position in vocabulary: %lld\n", st[a], bi[a]);
if (b == -1) {
printf("Out of dictionary word!\n");
break;
}
}
if (b == -1) continue;
printf("\n Word Cosine distance\n------------------------------------------------------------------------\n");
for (a = 0; a < size; a++) vec[a] = 0;
for (b = 0; b < cn; b++) {
if (bi[b] == -1) continue;
for (a = 0; a < size; a++) vec[a] += M[a + bi[b] * size];
}
len = 0;
for (a = 0; a < size; a++) len += vec[a] * vec[a];
len = sqrt(len);
for (a = 0; a < size; a++) vec[a] /= len;
for (a = 0; a < N; a++) bestd[a] = -1;
for (a = 0; a < N; a++) bestw[a][0] = 0;
for (c = 0; c < words; c++) {
a = 0;
for (b = 0; b < cn; b++) if (bi[b] == c) a = 1;
if (a == 1) continue;
dist = 0;
for (a = 0; a < size; a++) dist += vec[a] * M[a + c * size];
for (a = 0; a < N; a++) {
if (dist > bestd[a]) {
for (d = N - 1; d > a; d--) {
bestd[d] = bestd[d - 1];
strcpy(bestw[d], bestw[d - 1]);
}
bestd[a] = dist;
strcpy(bestw[a], &vocab[c * max_w]);
break;
}
}
}
for (a = 0; a < N; a++) printf("%50s\t\t%f\n", bestw[a], bestd[a]);
}
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x34158, %rsp # imm = 0x34158
cmpl $0x1, %edi
jg 0x1225
leaq 0xf63(%rip), %rdi # 0x217c
callq 0x10b0
xorl %eax, %eax
jmp 0x1846
movq 0x8(%rsi), %rsi
leaq 0x2c40(%rsp), %rbx
movq %rbx, %rdi
callq 0x1050
leaq 0xde4(%rip), %rsi # 0x2024
movq %rbx, %rdi
callq 0x1070
testq %rax, %rax
je 0x180e
movq %rax, %r15
leaq 0xdcc(%rip), %rbx # 0x2027
xorl %r12d, %r12d
leaq 0x10(%rsp), %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10f0
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10f0
movq (%r14), %rbx
imulq $0x32, %rbx, %rdi
callq 0x1080
movq %rax, 0x18(%rsp)
movl $0x7d0, %edi # imm = 0x7D0
callq 0x1080
movq %rax, 0xd0(%rsp,%r12,8)
incq %r12
cmpq $0x28, %r12
jne 0x1294
movq (%rsp), %r13
movq %r13, %r14
imulq %rbx, %r14
leaq (,%r14,4), %rdi
callq 0x1080
testq %rax, %rax
je 0x181c
testq %rbx, %rbx
movq %rax, 0x8(%rsp)
jle 0x141e
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x10d0
movl %eax, %ebp
imulq $0x32, %r14, %rax
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax), %r12
movb %bpl, (%rcx,%rax)
movq %r15, %rdi
callq 0x10c0
cmpb $0x20, %bpl
je 0x1355
movl $0x0, %r13d
testl %eax, %eax
jne 0x1358
xorl %r13d, %r13d
movq %r13, %rax
cmpq $0x32, %r13
setb %cl
cmpb $0xa, %bpl
setne %dl
andb %cl, %dl
movzbl %dl, %r13d
addq %rax, %r13
movq %r15, %rdi
callq 0x10d0
movl %eax, %ebp
movb %bpl, (%r12,%r13)
movq %r15, %rdi
callq 0x10c0
cmpb $0x20, %bpl
je 0x1358
testl %eax, %eax
je 0x1319
jmp 0x1358
xorl %r13d, %r13d
movb $0x0, (%r12,%r13)
movq (%rsp), %rdi
xorps %xmm0, %xmm0
testq %rdi, %rdi
jle 0x13c8
movq 0x8(%rsp), %rbp
movq %rbp, %r12
xorl %r13d, %r13d
imulq %rbx, %rdi
addq %r12, %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x10a0
incq %r13
movq (%rsp), %rdi
addq $0x4, %r12
cmpq %rdi, %r13
jl 0x1374
testq %rdi, %rdi
xorps %xmm0, %xmm0
jle 0x13cd
movq %rbx, %rax
imulq %rdi, %rax
addq %rbp, %rax
xorl %ecx, %ecx
movss (%rax,%rcx,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rdi
jne 0x13b1
jmp 0x13cd
movq 0x8(%rsp), %rbp
ucomiss 0xc4c(%rip), %xmm0 # 0x2020
jb 0x13dc
sqrtss %xmm0, %xmm0
jmp 0x13e1
callq 0x10e0
movq (%rsp), %rax
testq %rax, %rax
jle 0x140c
movq %rax, %rcx
imulq %rbx, %rcx
addq %rbp, %rcx
xorl %edx, %edx
movss (%rcx,%rdx,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %rax
jne 0x13f6
incq %r14
addq $0x4, %rbx
cmpq 0x10(%rsp), %r14
jl 0x12e3
movq %r15, %rdi
callq 0x1060
movq 0x208(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0xa0, %edx
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x1040
xorl %eax, %eax
movq 0xd0(%rsp,%rax,8), %rcx
movb $0x0, (%rcx)
incq %rax
cmpq $0x28, %rax
jne 0x1446
leaq 0xbfa(%rip), %rdi # 0x205b
xorl %eax, %eax
callq 0x1030
xorl %ebx, %ebx
movq 0x2b6f(%rip), %r14 # 0x3fe0
movq (%r14), %rdi
callq 0x10d0
movb %al, 0x530(%rsp,%rbx)
leaq 0x1(%rbx), %rcx
cmpb $0xa, %al
je 0x1494
cmpq $0x7cf, %rbx # imm = 0x7CF
movq %rcx, %rbx
jb 0x1471
movb $0x0, 0x52f(%rsp,%rcx)
movl 0x530(%rsp), %eax
movl $0x54495845, %ecx # imm = 0x54495845
xorl %ecx, %eax
movzbl 0x534(%rsp), %ecx
orl %eax, %ecx
je 0x121e
leaq 0x3411(%rsp), %rax
xorl %ecx, %ecx
xorl %r13d, %r13d
incq %rcx
movq %rax, %rdx
movb 0x52f(%rsp,%rcx), %sil
movb %sil, -0x1(%rdx)
movb $0x0, (%rdx)
movzbl 0x530(%rsp,%rcx), %esi
testl %esi, %esi
je 0x14fe
incq %rdx
incq %rcx
cmpl $0x20, %esi
jne 0x14cd
incq %r13
addq $0x7d0, %rax # imm = 0x7D0
jmp 0x14c7
xorl %r12d, %r12d
movq 0x10(%rsp), %r14
testq %r14, %r14
jle 0x1544
imulq $0x7d0, %r12, %rax # imm = 0x7D0
leaq (%rsp,%rax), %r15
addq $0x3410, %r15 # imm = 0x3410
movq 0x18(%rsp), %rbx
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1090
testl %eax, %eax
je 0x1546
incq %rbp
addq $0x32, %rbx
cmpq %rbp, %r14
jne 0x1524
movq %r14, %rbp
jmp 0x1546
xorl %ebp, %ebp
cmpq %r14, %rbp
movq %rbp, %rdx
movq $-0x1, %rax
cmoveq %rax, %rdx
movq %rdx, 0x210(%rsp,%r12,8)
imulq $0x7d0, %r12, %rax # imm = 0x7D0
leaq (%rsp,%rax), %rsi
addq $0x3410, %rsi # imm = 0x3410
leaq 0xb11(%rip), %rdi # 0x2089
xorl %eax, %eax
callq 0x1030
cmpq %r14, %rbp
je 0x165f
leaq 0x1(%r12), %rax
cmpq %r13, %r12
movq %rax, %r12
jne 0x1501
cmpq $-0x1, %rbp
movq 0x8(%rsp), %rbp
je 0x1433
leaq 0xb25(%rip), %rdi # 0x20d4
callq 0x10b0
movq (%rsp), %rbx
testq %rbx, %rbx
jle 0x15d4
leaq (,%rbx,4), %rdx
leaq 0xd00(%rsp), %rdi
xorl %esi, %esi
callq 0x1040
xorl %eax, %eax
testq %rbx, %rbx
setle %dl
movq 0x210(%rsp,%rax,8), %rcx
cmpq $-0x1, %rcx
sete %sil
orb %dl, %sil
jne 0x1621
imulq %rbx, %rcx
leaq (,%rcx,4), %rcx
addq %rbp, %rcx
xorl %edx, %edx
movss (%rcx,%rdx,4), %xmm0
addss 0xd00(%rsp,%rdx,4), %xmm0
movss %xmm0, 0xd00(%rsp,%rdx,4)
incq %rdx
cmpq %rdx, %rbx
jne 0x1602
leaq 0x1(%rax), %rcx
cmpq %r13, %rax
movq %rcx, %rax
jne 0x15d6
xorps %xmm0, %xmm0
testq %rbx, %rbx
jle 0x1650
xorl %eax, %eax
movss 0xd00(%rsp,%rax,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %rax
cmpq %rax, %rbx
jne 0x1637
ucomiss 0x9c9(%rip), %xmm0 # 0x2020
jb 0x1670
sqrtss %xmm0, %xmm0
jmp 0x1675
leaq 0xa56(%rip), %rdi # 0x20bc
callq 0x10b0
jmp 0x1433
callq 0x10e0
movaps 0x994(%rip), %xmm2 # 0x2010
movl $0x1, %edi
movq (%rsp), %rax
testq %rax, %rax
jle 0x16aa
xorl %ecx, %ecx
movss 0xd00(%rsp,%rcx,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, 0xd00(%rsp,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x168c
xorl %eax, %eax
movaps %xmm2, 0x30(%rsp,%rax,4)
addq $0x4, %rax
cmpq $0x28, %rax
jne 0x16ac
xorl %eax, %eax
movq 0xd0(%rsp,%rax,8), %rcx
movb $0x0, (%rcx)
incq %rax
cmpq $0x28, %rax
jne 0x16bd
movq 0x10(%rsp), %rax
testq %rax, %rax
jle 0x17dc
xorl %r15d, %r15d
xorl %r12d, %r12d
movq $-0x1, %rcx
xorl %edx, %edx
cmpq %r12, 0x218(%rsp,%rcx,8)
cmoveq %rdi, %rdx
incq %rcx
cmpq %rcx, %r13
jne 0x16ee
cmpq $0x1, %rdx
je 0x17cc
movq (%rsp), %rcx
testq %rcx, %rcx
jle 0x1740
movq %rcx, %rdx
imulq %r15, %rdx
addq %rbp, %rdx
xorps %xmm1, %xmm1
xorl %esi, %esi
movss 0xd00(%rsp,%rsi,4), %xmm0
mulss (%rdx,%rsi,4), %xmm0
addss %xmm0, %xmm1
incq %rsi
cmpq %rsi, %rcx
jne 0x1724
jmp 0x1743
xorps %xmm1, %xmm1
xorl %r14d, %r14d
ucomiss 0x30(%rsp,%r14,4), %xmm1
ja 0x1759
incq %r14
cmpq $0x28, %r14
jne 0x1746
jmp 0x17cc
movss %xmm1, 0x24(%rsp)
cmpq $0x26, %r14
ja 0x179a
movl $0x27, %eax
movq 0x28(%rsp), %rdi
leaq -0x1(%rax), %rbp
movss 0x2c(%rsp,%rax,4), %xmm0
movss %xmm0, 0x30(%rsp,%rax,4)
movq 0xc8(%rsp,%rax,8), %rbx
movq %rbx, %rsi
callq 0x1050
movq %rbx, %rdi
movq %rbp, %rax
cmpq %r14, %rbp
ja 0x176f
movss 0x24(%rsp), %xmm0
movss %xmm0, 0x30(%rsp,%r14,4)
movq 0xd0(%rsp,%r14,8), %rdi
imulq $0x32, %r12, %rsi
addq 0x18(%rsp), %rsi
callq 0x1050
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rbp
movl $0x1, %edi
incq %r12
addq $0x4, %r15
cmpq %rax, %r12
jl 0x16e5
xorl %ebx, %ebx
leaq 0x8cd(%rip), %r14 # 0x20b2
movq 0xd0(%rsp,%rbx,8), %rsi
xorps %xmm0, %xmm0
cvtss2sd 0x30(%rsp,%rbx,4), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1030
incq %rbx
cmpq $0x28, %rbx
jne 0x17e5
jmp 0x1433
leaq 0x952(%rip), %rdi # 0x2167
callq 0x10b0
jmp 0x1841
shrq $0x12, %r14
movabsq $0xfffffffffff, %rsi # imm = 0xFFFFFFFFFFF
andq %r14, %rsi
leaq 0x7f8(%rip), %rdi # 0x202c
movq %rbx, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x34158, %rsp # imm = 0x34158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/Leeheng86[P]word2vec/distance.c
|
stack4
|
int
stack4(unsigned short a, unsigned short b, unsigned short c, unsigned short d) {
// printf("stack4: %x,%x,%x,%x\n", a, b, c, d);
if (STACK16(S+1) + 1 != a) return 0;
if (STACK16(S+3) + 1 != b) return 0;
if (STACK16(S+5) + 1 != c) return 0;
if (STACK16(S+7) + 1 != d) return 0;
return 1;
}
|
leaq 0xdac9(%rip), %rax # 0x20128
movzbl (%rax), %r8d
leaq 0xdad6(%rip), %r9 # 0x20140
movzwl 0x101(%r8,%r9), %r10d
incl %r10d
xorl %eax, %eax
cmpl %edi, %r10d
jne 0x126e2
movzbl 0x103(%r8,%r9), %edi
movzbl 0x104(%r8,%r9), %r10d
shll $0x8, %r10d
addl %r10d, %edi
incl %edi
movzwl %si, %esi
cmpl %esi, %edi
jne 0x126e2
movzbl 0x105(%r8,%r9), %esi
movzbl 0x106(%r8,%r9), %edi
shll $0x8, %edi
addl %edi, %esi
incl %esi
movzwl %dx, %edx
cmpl %edx, %esi
jne 0x126e2
movzbl 0x107(%r8,%r9), %eax
movzbl 0x108(%r8,%r9), %edx
shll $0x8, %edx
addl %eax, %edx
incl %edx
movzwl %cx, %ecx
xorl %eax, %eax
cmpl %ecx, %edx
sete %al
retq
|
/workspace/github_c_makefile_star2_O3/mist64[P]cbmbasic/runtime.c
|
CHRGET_common
|
static void
CHRGET_common(int inc) {
unsigned short temp16;
if (!inc) goto CHRGOT_start;
CHRGET_start:
RAM[0x7A]++; SETSZ(RAM[0x7A]);
if (!Z) goto CHRGOT_start;
RAM[0x7B]++; SETSZ(RAM[0x7B]);
CHRGOT_start:
A = RAM[RAM[0x7A] | RAM[0x7B]<<8]; SETSZ(A);
temp16 = ((unsigned short)A) - ((unsigned short)0x3A); SETNC(temp16); SETSZ(temp16&0xFF);
if (C) return;
temp16 = ((unsigned short)A) - ((unsigned short)0x20); SETNC(temp16); SETSZ(temp16&0xFF);
if (Z) goto CHRGET_start;
C = 1;
temp16 = (unsigned short)A-(unsigned short)0x30-(unsigned short)(1-C); SETV(((A ^ temp16) & 0x80) && ((A ^ 0x30) & 0x80)); A = (unsigned char)temp16; SETSZ(A); SETNC(temp16);
C = 1;
temp16 = (unsigned short)A-(unsigned short)0xD0-(unsigned short)(1-C); SETV(((A ^ temp16) & 0x80) && ((A ^ 0xD0) & 0x80)); A = (unsigned char)temp16; SETSZ(A); SETNC(temp16);
}
|
testl %edi, %edi
je 0x12736
leaq 0xda4b(%rip), %rax # 0x20140
movb 0x7a(%rax), %al
leal 0x1(%rax), %esi
shrb $0x7, %sil
leaq 0xda3a(%rip), %rcx # 0x20140
leaq 0x1da37(%rip), %rdx # 0x30144
movb %sil, (%rdx)
incb %al
movb %al, 0x7a(%rcx)
leaq 0x1da27(%rip), %rax # 0x30143
sete (%rax)
jne 0x12736
movb 0x7b(%rcx), %sil
incb %sil
sete (%rax)
movb %sil, 0x7b(%rcx)
shrb $0x7, %sil
movb %sil, (%rdx)
leaq 0xda03(%rip), %rcx # 0x20140
movzwl 0x7a(%rcx), %eax
movzbl (%rcx,%rax), %ecx
leal 0xffc6(%rcx), %edx
testb %dl, %dl
leaq 0x1d9ef(%rip), %rsi # 0x30143
sete (%rsi)
movl %edx, %r9d
shrb $0x7, %r9b
btl $0x8, %edx
leaq 0x1d9dd(%rip), %rdx # 0x30146
setae (%rdx)
leaq 0x1d9d2(%rip), %r8 # 0x30145
movb %cl, (%r8)
leaq 0x1d9c7(%rip), %rdi # 0x30144
movb %r9b, (%rdi)
jae 0x127bb
leal 0xffe0(%rcx), %r9d
btl $0x8, %r9d
setae (%rdx)
testb %r9b, %r9b
je 0x126f8
addb $-0x30, %cl
movzbl %cl, %eax
addl $0xffffff30, %eax # imm = 0xFFFFFF30
testb %al, %al
sete (%rsi)
movb %al, (%r8)
movl %eax, %ecx
shrb $0x7, %cl
movb %cl, (%rdi)
btl $0x8, %eax
setae (%rdx)
retq
|
/workspace/github_c_makefile_star2_O3/mist64[P]cbmbasic/runtime.c
|
init_os
|
int
init_os(int argc, char **argv) {
// printf("init_os %d\n", argc);
if (!argc) /* continuation */
return PC;
if (argc>1) {
interactive = 0;
input_file = fopen(argv[1], "r");
if (!input_file) {
printf("Error opening: %s\n", argv[1]);
exit(1);
}
if (fgetc(input_file)=='#') {
char c;
do {
c = fgetc(input_file);
} while((c!=13)&&(c!=10));
} else {
fseek(input_file, 0, SEEK_SET);
}
} else {
interactive = 1;
input_file = NULL;
}
srand((unsigned int)time(NULL));
return 0xE394; /* main entry point of BASIC */
}
|
pushq %rbx
testl %edi, %edi
je 0x1281d
cmpl $0x2, %edi
jl 0x12829
movq %rsi, %rbx
movl $0x0, 0x1da4a(%rip) # 0x30224
movq 0x8(%rsi), %rdi
leaq 0xb023(%rip), %rsi # 0x1d808
callq 0x11f0
movq %rax, 0x1da37(%rip) # 0x30228
testq %rax, %rax
je 0x12865
movq %rax, %rdi
callq 0x1110
cmpl $0x23, %eax
jne 0x12840
movq 0x1da1e(%rip), %rdi # 0x30228
callq 0x1110
cmpb $0xa, %al
je 0x12850
movzbl %al, %eax
cmpl $0xd, %eax
jne 0x12803
jmp 0x12850
leaq 0x1d91c(%rip), %rax # 0x30140
movzwl (%rax), %eax
jmp 0x12863
movl $0x1, 0x1d9f1(%rip) # 0x30224
movq $0x0, 0x1d9ea(%rip) # 0x30228
jmp 0x12850
movq 0x1d9e1(%rip), %rdi # 0x30228
xorl %esi, %esi
xorl %edx, %edx
callq 0x11e0
xorl %edi, %edi
callq 0x1190
movl %eax, %edi
callq 0x1140
movl $0xe394, %eax # imm = 0xE394
popq %rbx
retq
movq 0x8(%rbx), %rsi
leaq 0xaf9a(%rip), %rdi # 0x1d80a
xorl %eax, %eax
callq 0x10c0
movl $0x1, %edi
callq 0x1200
|
/workspace/github_c_makefile_star2_O3/mist64[P]cbmbasic/runtime.c
|
plugin_on
|
void
plugin_on() {
if (plugin)
return;
replace_vector(VEC_ERROR, MAGIC_ERROR, &orig_error);
replace_vector(VEC_MAIN, MAGIC_MAIN, &orig_main);
replace_vector(VEC_CRNCH, MAGIC_CRNCH, &orig_crnch);
replace_vector(VEC_QPLOP, MAGIC_QPLOP, &orig_qplop);
replace_vector(VEC_GONE, MAGIC_GONE, &orig_gone);
replace_vector(VEC_EVAL, MAGIC_EVAL, &orig_eval);
plugin = 1;
}
|
cmpl $0x0, 0x1d98e(%rip) # 0x30230
je 0x128a5
retq
leaq 0xd894(%rip), %rax # 0x20140
movzwl 0x300(%rax), %ecx
movzwl 0x302(%rax), %edx
movw %cx, 0x1d973(%rip) # 0x30234
movw %dx, 0x1d96e(%rip) # 0x30236
movzwl 0x304(%rax), %ecx
movw %cx, 0x1d962(%rip) # 0x30238
movzwl 0x306(%rax), %ecx
movw %cx, 0x1d956(%rip) # 0x3023a
movabsq $-0xfc00fd00fe0100, %rcx # imm = 0xFF03FF02FF01FF00
movq %rcx, 0x300(%rax)
movzwl 0x308(%rax), %ecx
movw %cx, 0x1d939(%rip) # 0x3023c
movzwl 0x30a(%rax), %ecx
movw %cx, 0x1d92d(%rip) # 0x3023e
movl $0xff05ff04, 0x308(%rax) # imm = 0xFF05FF04
movl $0x1, 0x1d90b(%rip) # 0x30230
retq
|
/workspace/github_c_makefile_star2_O3/mist64[P]cbmbasic/runtime.c
|
kernal_dispatch
|
int
kernal_dispatch() {
//{ printf("kernal_dispatch $%04X; ", PC); int i; printf("stack (%02X): ", S); for (i=S+1; i<0x100; i++) { printf("%02X ", RAM[0x0100+i]); } printf("\n"); }
unsigned int new_pc;
switch(PC) {
case 0x0073: CHRGET(); break;
case 0x0079: CHRGOT(); break;
case 0xFF90: SETMSG(); break;
case 0xFF99: MEMTOP(); break;
case 0xFF9C: MEMBOT(); break;
case 0xFFB7: READST(); break;
case 0xFFBA: SETLFS(); break;
case 0xFFBD: SETNAM(); break;
case 0xFFC0: OPEN(); break;
case 0xFFC3: CLOSE(); break;
case 0xFFC6: CHKIN(); break;
case 0xFFC9: CHKOUT(); break;
case 0xFFCC: CLRCHN(); break;
case 0xFFCF: CHRIN(); break;
case 0xFFD2: CHROUT(); break;
case 0xFFD5: LOAD(); break;
case 0xFFD8: SAVE(); break;
case 0xFFDB: SETTIM(); break;
case 0xFFDE: RDTIM(); break;
case 0xFFE1: STOP(); break;
case 0xFFE4: GETIN(); break;
case 0xFFE7: CLALL(); break;
case 0xFFF0: PLOT(); break;
case 0xFFF3: IOBASE(); break;
case 0: plugin_off(); S+=2; break;
case 1: plugin_on(); S+=2; break;
case MAGIC_ERROR: new_pc = plugin_error(); PUSH_WORD(new_pc? new_pc-1:orig_error-1); break;
case MAGIC_MAIN: new_pc = plugin_main(); PUSH_WORD(new_pc? new_pc-1:orig_main-1); break;
case MAGIC_CRNCH: new_pc = plugin_crnch(); PUSH_WORD(new_pc? new_pc-1:orig_crnch-1); break;
case MAGIC_QPLOP: new_pc = plugin_qplop(); PUSH_WORD(new_pc? new_pc-1:orig_qplop-1); break;
case MAGIC_GONE: new_pc = plugin_gone(); PUSH_WORD(new_pc? new_pc-1:orig_gone-1); break;
case MAGIC_EVAL: new_pc = plugin_eval(); PUSH_WORD(new_pc? new_pc-1:orig_eval-1); break;
case MAGIC_CONTINUATION: /*printf("--CONTINUATION--\n");*/ return 0;
default: printf("unknown PC=$%04X S=$%02X\n", PC, S); exit(1);
}
return 1;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq 0x1d802(%rip), %rax # 0x30140
movzwl (%rax), %esi
cmpl $0xffc5, %esi # imm = 0xFFC5
jg 0x12994
cmpl $0xff8f, %esi # imm = 0xFF8F
jg 0x12a79
cmpl $0x78, %esi
jle 0x12bba
leal -0xff00(%rsi), %eax
cmpl $0x5, %eax
ja 0x132d1
leaq 0xacfc(%rip), %rcx # 0x1d670
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x13a5c
movzwl %ax, %edx
leal -0x1(%rdx), %esi
movzwl 0x1d8a5(%rip), %edi # 0x30234
jmp 0x13348
cmpl $0xffdd, %esi # imm = 0xFFDD
jg 0x12ac2
leal -0xffc6(%rsi), %eax
cmpl $0x9, %eax
jbe 0x12be8
leal -0xffd2(%rsi), %eax
cmpl $0x9, %eax
ja 0x139e7
leaq 0xad13(%rip), %rcx # 0x1d6d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x1d850(%rip), %ebx # 0x30224
testl %ebx, %ebx
je 0x134c1
movl $0xe10f, %edi # imm = 0xE10F
movl $0xab4a, %esi # imm = 0xAB4A
movl $0xab30, %edx # imm = 0xAB30
movl $0xa47b, %ecx # imm = 0xA47B
callq 0x12658
testl %eax, %eax
je 0x12a13
leaq 0x1d745(%rip), %rax # 0x30145
cmpb $0x52, (%rax)
jne 0x12a0b
incl 0x1d815(%rip) # 0x30220
testl %ebx, %ebx
je 0x1358b
movl $0xe10f, %edi # imm = 0xE10F
movl $0xab4a, %esi # imm = 0xAB4A
movl $0xaadc, %edx # imm = 0xAADC
movl $0xa486, %ecx # imm = 0xA486
callq 0x12658
testl %eax, %eax
jne 0x1358b
movzbl 0x1d71d(%rip), %eax # 0x30158
testq %rax, %rax
je 0x137cc
leaq 0x1d6fa(%rip), %rbx # 0x30145
movzbl (%rbx), %edi
leaq 0x1d70b(%rip), %rcx # 0x30160
movq (%rcx,%rax,8), %rsi
callq 0x1130
cmpl $-0x1, %eax
jne 0x1358b
leaq 0x1d6d8(%rip), %rax # 0x30146
movb $0x1, (%rax)
movb $0x7, (%rbx)
jmp 0x13595
cmpl $0xffb6, %esi # imm = 0xFFB6
jg 0x12b69
cmpl $0xff90, %esi # imm = 0xFF90
je 0x12c51
cmpl $0xff99, %esi # imm = 0xFF99
je 0x12c6d
cmpl $0xff9c, %esi # imm = 0xFF9C
jne 0x139e7
leaq 0x1d692(%rip), %rax # 0x30142
movb $0x0, (%rax)
leaq 0x1d68e(%rip), %rax # 0x30148
movb $0x8, (%rax)
jmp 0x13595
cmpl $0xffef, %esi # imm = 0xFFEF
jg 0x12c26
leal -0xffde(%rsi), %eax
cmpl $0x9, %eax
ja 0x139e7
leaq 0xac1c(%rip), %rcx # 0x1d700
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %edi, %edi
callq 0x1190
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x28(%rsp), %rbx
movq %rbx, %rsi
callq 0x1040
leaq 0x18(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x10d0
imull $0x3c, 0x8(%rbx), %eax
addl 0x4(%rbx), %eax
imull $0x3c, %eax, %ecx
addl (%rbx), %ecx
movabsq $0x7dd58b133365889f, %rax # imm = 0x7DD58B133365889F
imulq 0x8(%r14)
imull $0x3c, %ecx, %eax
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0xd, %rdx
addq %rcx, %rdx
addq %rax, %rdx
leaq 0x1d5f5(%rip), %rax # 0x30142
movb %dh, (%rax)
leaq 0x1d5ef(%rip), %rax # 0x30145
movb %dl, (%rax)
movl %edx, %eax
shrl $0x10, %eax
leaq 0x1d5e4(%rip), %rcx # 0x30148
jmp 0x1345d
leal -0xffba(%rsi), %eax
cmpl $0x9, %eax
ja 0x1338e
leaq 0xab09(%rip), %rcx # 0x1d688
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1d5b6(%rip), %rax # 0x30145
movb (%rax), %al
movb %al, 0x1d6b6(%rip) # 0x3024d
leaq 0x1d5a4(%rip), %rax # 0x30142
movb (%rax), %al
movb %al, 0x1d6a8(%rip) # 0x3024e
leaq 0x1d59b(%rip), %rax # 0x30148
movb (%rax), %al
movb %al, 0x1d69a(%rip) # 0x3024f
jmp 0x13595
testl %esi, %esi
je 0x12c86
cmpl $0x1, %esi
je 0x12cf6
cmpl $0x73, %esi
jne 0x139e7
movl $0x1, %ebx
movl $0x1, %edi
callq 0x126ea
jmp 0x1359a
leaq 0xaac1(%rip), %rcx # 0x1d6b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, 0x1d551(%rip) # 0x30150
leaq 0x1d53c(%rip), %rax # 0x30142
movzbl (%rax), %eax
leaq 0x1d550(%rip), %rcx # 0x30160
cmpq $0x0, (%rcx,%rax,8)
je 0x1344a
movb %al, 0x1d538(%rip) # 0x30159
jmp 0x13446
cmpl $0xfff0, %esi # imm = 0xFFF0
je 0x12e20
cmpl $0xfff3, %esi # imm = 0xFFF3
je 0x12e5f
xorl %ebx, %ebx
cmpl $0xffff, %esi # imm = 0xFFFF
je 0x1359a
jmp 0x139e7
leaq 0x1d4ed(%rip), %rax # 0x30145
movb (%rax), %cl
movb %cl, 0x1d5e8(%rip) # 0x30248
movb 0x1d4ea(%rip), %cl # 0x30150
movb %cl, (%rax)
jmp 0x13595
leaq 0x1d4ce(%rip), %rax # 0x30142
movb $0x0, (%rax)
leaq 0x1d4ca(%rip), %rax # 0x30148
movb $-0x60, (%rax)
jmp 0x13595
cmpl $0x0, 0x1d5a3(%rip) # 0x30230
je 0x12cfb
movzwl 0x1d59e(%rip), %eax # 0x30234
leaq 0xd4a3(%rip), %rcx # 0x20140
movw %ax, 0x300(%rcx)
movzwl 0x1d58b(%rip), %eax # 0x30236
movw %ax, 0x302(%rcx)
movzwl 0x1d57f(%rip), %eax # 0x30238
movw %ax, 0x304(%rcx)
movzwl 0x1d573(%rip), %eax # 0x3023a
movw %ax, 0x306(%rcx)
movzwl 0x1d567(%rip), %eax # 0x3023c
movw %ax, 0x308(%rcx)
movzwl 0x1d55b(%rip), %eax # 0x3023e
movw %ax, 0x30a(%rcx)
movl $0x0, 0x1d53c(%rip) # 0x30230
jmp 0x12cfb
callq 0x1289b
leaq 0xd426(%rip), %rax # 0x20128
addb $0x2, (%rax)
jmp 0x13595
xorl %eax, %eax
movb %al, 0x1d447(%rip) # 0x30159
movb %al, 0x1d440(%rip) # 0x30158
jmp 0x13595
movb $0x0, 0x1d42c(%rip) # 0x30150
leaq 0x1d417(%rip), %rax # 0x30142
movzbl (%rax), %eax
leaq 0x1d42b(%rip), %rcx # 0x30160
cmpq $0x0, (%rcx,%rax,8)
je 0x1344a
movb %al, 0x1d412(%rip) # 0x30158
jmp 0x13446
cmpl $0x0, 0x1d4d2(%rip) # 0x30224
jne 0x12d61
cmpl $0x2, 0x1d4c5(%rip) # 0x30220
je 0x139b5
movzbl 0x1d3f1(%rip), %eax # 0x30159
testq %rax, %rax
je 0x13525
leaq 0x1d3e8(%rip), %rbx # 0x30160
movq (%rbx,%rax,8), %rdi
callq 0x1160
testl %eax, %eax
je 0x13464
orb $0x42, 0x1d3c0(%rip) # 0x30150
leaq 0x1d3ae(%rip), %rax # 0x30145
movb $0xd, (%rax)
jmp 0x1358b
leaq 0x1d39d(%rip), %rax # 0x30143
jmp 0x13592
movzbl 0x1d3a7(%rip), %eax # 0x30159
testq %rax, %rax
je 0x13573
leaq 0x1d39e(%rip), %rbx # 0x30160
movq (%rbx,%rax,8), %rdi
callq 0x1160
testl %eax, %eax
je 0x13464
orb $0x42, 0x1d376(%rip) # 0x30150
leaq 0x1d364(%rip), %rax # 0x30145
movb $-0x39, (%rax)
jmp 0x1358b
xorl %r14d, %r14d
leaq 0x1d36d(%rip), %r15 # 0x30160
movl $0x1, %ebx
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x12e0e
callq 0x1070
movq $0x0, (%r14,%r15)
addq $0x8, %r14
cmpq $0x80, %r14
jne 0x12df8
jmp 0x1359a
leaq 0x1d31f(%rip), %rax # 0x30146
cmpb $0x0, (%rax)
je 0x139bc
leaq 0x28(%rsp), %rbx
leaq 0x18(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13f36
movb (%rbx), %al
leaq 0x1d2fa(%rip), %rcx # 0x30148
movb %al, (%rcx)
movb (%r14), %al
leaq 0x1d2e8(%rip), %rcx # 0x30142
jmp 0x133a7
callq 0x1220
leaq 0xd2d5(%rip), %rbx # 0x20140
movw %ax, 0xdc04(%rbx)
callq 0x1220
movw %ax, 0xdc08(%rbx)
leaq 0x1d2bd(%rip), %rax # 0x30142
movb $0x0, (%rax)
leaq 0x1d2b9(%rip), %rax # 0x30148
movb $-0x24, (%rax)
jmp 0x13595
leaq 0x1d2a7(%rip), %r14 # 0x30145
movzbl (%r14), %eax
leaq 0xd297(%rip), %rdi # 0x20140
movzwl (%rdi,%rax), %ebp
leaq 0x1d28e(%rip), %rax # 0x30142
movzbl (%rax), %eax
leaq 0x1d28a(%rip), %rcx # 0x30148
movzbl (%rcx), %r15d
shll $0x8, %r15d
orl %eax, %r15d
movb $0x1, %r12b
subl %ebp, %r15d
jb 0x12f48
movzbl 0x1d374(%rip), %eax # 0x3024c
testq %rax, %rax
je 0x136a8
movzwl 0x1d362(%rip), %ecx # 0x3024a
addq %rcx, %rax
movb $0x0, (%rdi,%rax)
addq %rcx, %rdi
leaq 0xa962(%rip), %rsi # 0x1d85b
callq 0x11f0
testq %rax, %rax
je 0x136ac
movq %rax, %rbx
movzbl %bpl, %edi
movq %rax, %rsi
callq 0x1130
movl %ebp, %edi
shrl $0x8, %edi
movq %rbx, %rsi
callq 0x1130
movzwl %bp, %edi
addq 0xd09b(%rip), %rdi # 0x1ffc8
movslq %r15d, %rsi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1210
movq %rbx, %rdi
callq 0x1070
xorl %r12d, %r12d
xorl %eax, %eax
jmp 0x136ae
leaq 0x1d1ef(%rip), %r12 # 0x30145
cmpb $0x0, (%r12)
jne 0x139d9
movzbl 0x1d2e4(%rip), %eax # 0x3024c
movb $0x1, %r13b
testq %rax, %rax
je 0x135ae
movzwl 0x1d2cf(%rip), %ecx # 0x3024a
leaq 0xd1be(%rip), %rbp # 0x20140
cmpb $0x24, (%rbp,%rcx)
jne 0x135b6
movl $0x22120000, 0x803(%rbp) # imm = 0x22120000
movaps 0xa6c2(%rip), %xmm0 # 0x1d660
movups %xmm0, 0x807(%rbp)
leaq 0x807(%rbp), %rbx
movl $0x100, %esi # imm = 0x100
movq %rbx, %rdi
callq 0x1100
movb $0x5, %r14b
testq %rax, %rax
je 0x1384a
movq %rbx, %rdi
callq 0x1090
movq %rax, %rbx
leal 0x807(%rax), %ecx
leal 0x808(%rax), %edx
movl $0xffff, %eax # imm = 0xFFFF
andl %eax, %ecx
movb $0x22, (%rbp,%rcx)
leal 0x809(%rbx), %ecx
andl %eax, %edx
movb $0x20, %sil
movb %sil, (%rbp,%rdx)
leal 0x80a(%rbx), %edx
andl %eax, %ecx
movb $0x30, %dil
movb %dil, (%rbp,%rcx)
leal 0x80b(%rbx), %ecx
andl %eax, %edx
movb %dil, (%rbp,%rdx)
leal 0x80c(%rbx), %edx
andl %eax, %ecx
movb %sil, (%rbp,%rcx)
leal 0x80d(%rbx), %ecx
andl %eax, %edx
movb $0x32, (%rbp,%rdx)
leal 0x80e(%rbx), %edx
andl %eax, %ecx
movb $0x41, (%rbp,%rcx)
addl $0x80f, %ebx # imm = 0x80F
andl %eax, %edx
movb $0x0, (%rbp,%rdx)
movb %bl, 0x801(%rbp)
movb %bh, 0x802(%rbp)
leaq 0xa7dd(%rip), %rdi # 0x1d839
callq 0x1080
testq %rax, %rax
je 0x1384a
movq %rax, (%rsp)
movq %rax, %rdi
callq 0x11b0
testq %rax, %rax
je 0x1380e
movq %rax, %r12
movl $0xffff, %r15d # imm = 0xFFFF
leaq 0xd0b1(%rip), %rbp # 0x20140
addq $0x13, %r12
movq %r12, %rdi
callq 0x1090
movq %rax, %r13
movq %r12, %rdi
leaq 0x28(%rsp), %rsi
callq 0x1170
movq 0x58(%rsp), %rax
movl $0xfd, %ecx
addq %rcx, %rax
movabsq $0x4081020408102041, %rcx # imm = 0x4081020408102041
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x6, %rdx
addl %eax, %edx
cmpl %r15d, %edx
movl $0xffff, %eax # imm = 0xFFFF
cmovll %edx, %eax
movzwl %bx, %edi
leal 0x2(%rbx), %ecx
leal 0x3(%rbx), %esi
andl %r15d, %ecx
movb %al, (%rbp,%rcx)
leal 0x4(%rbx), %r14d
andl %r15d, %esi
movb %ah, (%rbp,%rsi)
cmpl $0x3e7, %edx # imm = 0x3E7
movq %rbp, %rsi
movq %rdi, 0x8(%rsp)
jg 0x1313b
leal 0x5(%rdi), %eax
movzwl %r14w, %ecx
movb $0x20, (%rsi,%rcx)
cmpl $0x63, %edx
jg 0x13138
leal 0x6(%rdi), %r14d
movzwl %ax, %eax
movb $0x20, (%rsi,%rax)
cmpl $0x9, %edx
jg 0x1313b
movzwl %r14w, %eax
leal 0x7(%rdi), %ecx
movb $0x20, (%rsi,%rax)
movl %ecx, %r14d
jmp 0x1313b
movl %eax, %r14d
leal 0x1(%r14), %edi
movzwl %r14w, %eax
movb $0x22, %cl
movb %cl, (%rsi,%rax)
cmpq $0x10, %r13
movl $0x10, %ebp
cmovbq %r13, %rbp
movl $0xffff, %r15d # imm = 0xFFFF
andl %r15d, %edi
addq %rsi, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1180
leaq 0xcfcd(%rip), %rdx # 0x20140
leal (%r14,%rbp), %ebx
incl %ebx
movl %ebx, %eax
andl %r15d, %eax
movb $0x22, %cl
movb %cl, (%rdx,%rax)
cmpq $0xf, %r13
ja 0x131a2
addl $-0x10, %ebp
movq (%rsp), %rdi
incl %ebx
movzwl %bx, %eax
movb $0x20, (%rdx,%rax)
incl %ebp
jne 0x13190
leal 0x1(%rbx), %eax
jmp 0x131ad
leal (%r14,%rbp), %eax
addl $0x2, %eax
movq (%rsp), %rdi
movl $0xffff, %r15d # imm = 0xFFFF
leal 0x2(%rbx), %ecx
movzwl %ax, %eax
movb $0x20, %sil
movb %sil, (%rdx,%rax)
leal 0x3(%rbx), %eax
andl %r15d, %ecx
movb $0x50, (%rdx,%rcx)
leal 0x4(%rbx), %ecx
andl %r15d, %eax
movb $0x52, (%rdx,%rax)
leal 0x5(%rbx), %eax
andl %r15d, %ecx
movb $0x47, (%rdx,%rcx)
leal 0x6(%rbx), %ecx
andl %r15d, %eax
movb %sil, (%rdx,%rax)
leal 0x7(%rbx), %eax
andl %r15d, %ecx
movb %sil, (%rdx,%rcx)
addl $0x8, %ebx
andl %r15d, %eax
movb $0x0, (%rdx,%rax)
movq 0x8(%rsp), %rax
movb %bl, (%rdx,%rax)
movb %bh, 0x1(%rdx,%rax)
movq %rdx, %rbp
callq 0x11b0
movq %rax, %r12
testq %rax, %rax
jne 0x1308f
jmp 0x13815
leaq 0x1cf20(%rip), %rax # 0x30148
movzbl (%rax), %eax
shll $0x10, %eax
leaq 0x1cf0d(%rip), %rcx # 0x30142
movzbl (%rcx), %ecx
shll $0x8, %ecx
orl %eax, %ecx
leaq 0x1cf01(%rip), %rax # 0x30145
movzbl (%rax), %r14d
orl %ecx, %r14d
xorl %edi, %edi
callq 0x1190
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x28(%rsp), %rbx
movq %rbx, %rsi
callq 0x1040
imulq $0x4444445, %r14, %r15 # imm = 0x4444445
shrq $0x20, %r15
imulq $0x8888889, %r15, %rax # imm = 0x8888889
shrq $0x21, %rax
imull $0x3c, %eax, %eax
movl %r15d, %ecx
subl %eax, %ecx
movl %ecx, (%rbx)
imulq $0x2468ad, %r14, %rax # imm = 0x2468AD
shrq $0x21, %rax
movl %eax, 0x4(%rbx)
imulq $0x136b06f, %r14, %rax # imm = 0x136B06F
shrq $0x2a, %rax
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x11d0
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
imull $0x3c, %r15d, %eax
subl %eax, %r14d
imull $0x411a, %r14d, %eax # imm = 0x411A
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x11a0
jmp 0x13595
cmpl $0x79, %esi
jne 0x139e7
xorl %edi, %edi
callq 0x126ea
jmp 0x13595
callq 0x13a68
movzwl %ax, %edx
leal -0x1(%rdx), %esi
movzwl 0x1cf44(%rip), %edi # 0x3023c
jmp 0x13348
callq 0x13a62
movzwl %ax, %edx
leal -0x1(%rdx), %esi
movzwl 0x1cf2c(%rip), %edi # 0x30238
jmp 0x13348
callq 0x13a65
movzwl %ax, %edx
leal -0x1(%rdx), %esi
movzwl 0x1cf1a(%rip), %edi # 0x3023a
jmp 0x13348
callq 0x13a5f
movzwl %ax, %edx
leal -0x1(%rdx), %esi
movzwl 0x1cf02(%rip), %edi # 0x30236
jmp 0x13348
callq 0x13e65
movzwl %ax, %edx
leal -0x1(%rdx), %esi
movzwl 0x1cef6(%rip), %edi # 0x3023e
leal -0x1(%rdi), %ecx
leaq 0xcdd6(%rip), %r8 # 0x20128
movzbl (%r8), %eax
leal -0x1(%rax), %r9d
decb %dil
testw %dx, %dx
cmovnel %esi, %ecx
leaq 0xcdd6(%rip), %rdx # 0x20140
movb %ch, 0x100(%rdx,%rax)
movzbl %dil, %ecx
cmovnel %esi, %ecx
addl $-0x2, %eax
movb %al, (%r8)
movzbl %r9b, %eax
movb %cl, 0x100(%rdx,%rax)
jmp 0x13595
cmpl $0xffb7, %esi # imm = 0xFFB7
jne 0x139e7
movb 0x1cdb0(%rip), %al # 0x30150
leaq 0x1cd9e(%rip), %rcx # 0x30145
movb %al, (%rcx)
jmp 0x13595
leaq 0x1cd8d(%rip), %rax # 0x30142
movzbl (%rax), %eax
leaq 0x1cd89(%rip), %rcx # 0x30148
movzbl (%rcx), %ecx
shll $0x8, %ecx
orl %eax, %ecx
movw %cx, 0x1ce7c(%rip) # 0x3024a
leaq 0x1cd70(%rip), %rax # 0x30145
movb (%rax), %al
movb %al, 0x1ce6f(%rip) # 0x3024c
jmp 0x13595
movb $0x0, 0x1cd67(%rip) # 0x30150
movzbl 0x1ce5d(%rip), %eax # 0x3024d
leaq 0x1cd69(%rip), %rbx # 0x30160
cmpq $0x0, (%rbx,%rax,8)
je 0x13621
leaq 0x1cd3d(%rip), %rax # 0x30146
movb $0x1, (%rax)
leaq 0x1cd32(%rip), %rax # 0x30145
movb $0x2, (%rax)
jmp 0x13595
movzbl 0x1ce2b(%rip), %eax # 0x3024d
leaq 0x1cd37(%rip), %rbx # 0x30160
movq (%rbx,%rax,8), %rdi
testq %rdi, %rdi
je 0x1344a
callq 0x1070
movzbl 0x1ce0f(%rip), %eax # 0x3024d
movq $0x0, (%rbx,%rax,8)
xorl %eax, %eax
jmp 0x13456
leaq 0x1ccf4(%rip), %rax # 0x30145
movb $0x3, (%rax)
movb $0x1, %al
leaq 0x1cce9(%rip), %rcx # 0x30146
movb %al, (%rcx)
jmp 0x13595
movzbl 0x1ccee(%rip), %ecx # 0x30159
leaq 0x1cd6e(%rip), %r14 # 0x301e0
movl (%r14,%rcx,4), %eax
cmpl $-0x1, %eax
jne 0x1348f
movq (%rbx,%rcx,8), %rdi
callq 0x1110
movzbl 0x1ccce(%rip), %ecx # 0x30159
movl %eax, (%r14,%rcx,4)
leaq 0x1ccaf(%rip), %rdx # 0x30145
movb %al, (%rdx)
movq (%rbx,%rcx,8), %rdi
callq 0x1110
movzbl 0x1ccb1(%rip), %ecx # 0x30159
movl %eax, (%r14,%rcx,4)
cmpl $-0x1, %eax
jne 0x1358b
orb $0x40, 0x1cc94(%rip) # 0x30150
jmp 0x1358b
movl $0xe10f, %edi # imm = 0xE10F
movl $0xab4a, %esi # imm = 0xAB4A
movl $0xab30, %edx # imm = 0xAB30
movl $0xe430, %ecx # imm = 0xE430
callq 0x12658
testl %eax, %eax
jne 0x1358b
movl $0xe10f, %edi # imm = 0xE10F
movl $0xab4a, %esi # imm = 0xAB4A
movl $0xab30, %edx # imm = 0xAB30
movl $0xe43d, %ecx # imm = 0xE43D
callq 0x12658
testl %eax, %eax
jne 0x1358b
movl $0xe10f, %edi # imm = 0xE10F
movl $0xab4a, %esi # imm = 0xAB4A
movl $0xab30, %edx # imm = 0xAB30
movl $0xe444, %ecx # imm = 0xE444
callq 0x12658
testl %eax, %eax
jne 0x1358b
jmp 0x129dc
movq 0x1ccfc(%rip), %rdi # 0x30228
testq %rdi, %rdi
je 0x13573
cmpl $0x0, 0x1cd08(%rip) # 0x30240
je 0x13777
movslq 0x1ccff(%rip), %rax # 0x30244
leal 0x1(%rax), %ecx
movl %ecx, 0x1ccf6(%rip) # 0x30244
leaq 0xa332(%rip), %rdx # 0x1d887
movb (%rax,%rdx), %al
leaq 0x1cbe6(%rip), %rdx # 0x30145
movb %al, (%rdx)
cmpl $0x4, %ecx
jne 0x1358b
movq $0x0, 0x1ccb7(%rip) # 0x30228
jmp 0x1358b
callq 0x1150
cmpb $0xa, %al
movl $0xd, %ecx
cmovnel %eax, %ecx
leaq 0x1cbbc(%rip), %rax # 0x30145
movb %cl, (%rax)
leaq 0x1cbb4(%rip), %rax # 0x30146
movb $0x0, (%rax)
movl $0x1, %ebx
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x8, %r14b
jmp 0x1384a
leaq (%rcx,%rbp), %rdi
addq %rcx, %rax
movb $0x0, (%rbp,%rax)
leaq 0x28(%rsp), %rsi
callq 0x1170
movb $0x4, %r14b
cmpl $-0x1, %eax
je 0x1384a
movl $0xf000, %eax # imm = 0xF000
andl 0x40(%rsp), %eax
movzwl 0x1cc62(%rip), %edi # 0x3024a
addq 0xc9d9(%rip), %rdi # 0x1ffc8
cmpl $0x4000, %eax # imm = 0x4000
jne 0x136d6
callq 0x10a0
cmpl $-0x1, %eax
je 0x1386d
leaq 0xcb31(%rip), %rax # 0x20140
movw $0x0, 0x801(%rax)
movw $0x803, %bx # imm = 0x803
jmp 0x13832
movzbl 0x1cc24(%rip), %eax # 0x3024c
testq %rax, %rax
je 0x136c0
movzwl 0x1cc12(%rip), %edi # 0x3024a
addq %rdi, %rax
leaq 0xcafe(%rip), %r14 # 0x20140
movb (%r14,%rax), %bpl
cmpb $0x0, 0x1cc02(%rip) # 0x3024f
leaq 0xa1b4(%rip), %rcx # 0x1d808
leaq 0xa1dc(%rip), %rsi # 0x1d837
cmoveq %rcx, %rsi
movb $0x0, (%r14,%rax)
addq %r14, %rdi
callq 0x11f0
movzbl 0x1cbda(%rip), %ecx # 0x3024d
movq %rax, (%rbx,%rcx,8)
movzwl 0x1cbcc(%rip), %edx # 0x3024a
movzbl 0x1cbc7(%rip), %esi # 0x3024c
addq %rdx, %rsi
movb %bpl, (%r14,%rsi)
testq %rax, %rax
je 0x137b3
leaq 0x1cb44(%rip), %rax # 0x301e0
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x1358b
movb $0x8, %al
jmp 0x136ae
movb $0x4, %al
leaq 0x1ca91(%rip), %rcx # 0x30146
movb %r12b, (%rcx)
movb %al, (%r14)
jmp 0x13595
leaq 0x1ca7f(%rip), %rax # 0x30146
movb $0x1, (%rax)
leaq 0x1ca74(%rip), %rax # 0x30145
jmp 0x12aba
leaq 0xa15e(%rip), %rsi # 0x1d83b
callq 0x11f0
testq %rax, %rax
je 0x1384a
movq %rax, %r15
movq %rax, %rdi
callq 0x1110
movzbl %al, %ebp
movq %r15, %rdi
callq 0x1110
shll $0x8, %eax
orl %eax, %ebp
leaq 0x1ca35(%rip), %rax # 0x30142
movzbl (%rax), %eax
leaq 0x1ca31(%rip), %rcx # 0x30148
movzbl (%rcx), %ebx
shll $0x8, %ebx
orl %eax, %ebx
cmpb $0x0, 0x1cb29(%rip) # 0x3024f
cmovnel %ebp, %ebx
movl $0xffff, %ebp # imm = 0xFFFF
movl %ebx, %r14d
andl %ebp, %r14d
leaq 0xca05(%rip), %rdi # 0x20140
addq %r14, %rdi
movl $0x10000, %edx # imm = 0x10000
subl %r14d, %edx
movl $0x1, %esi
movq %r15, %rcx
callq 0x1060
addl %eax, %ebx
movl %ebx, %edx
andl %ebp, %edx
leaq 0xa0de(%rip), %rdi # 0x1d83e
movl %r14d, %esi
xorl %eax, %eax
callq 0x10c0
movq %r15, %rdi
callq 0x1070
jmp 0x13832
callq 0x1110
leaq 0x1c9c2(%rip), %rcx # 0x30145
movb %al, (%rcx)
cmpb $-0x1, %al
jne 0x1385d
cmpl $0x1, 0x1ca8c(%rip) # 0x30220
jne 0x1385d
movl $0x1, %eax
movl %eax, 0x1ca9b(%rip) # 0x30240
movl %eax, 0x1ca99(%rip) # 0x30244
movb $0x52, (%rcx)
jmp 0x1358b
leaq 0x1c98c(%rip), %rax # 0x30146
movb $0x1, (%rax)
leaq 0x1c981(%rip), %rax # 0x30145
movb $0x4, (%rax)
jmp 0x13595
cmpl $0x0, 0x1c981(%rip) # 0x30154
leaq 0x1c96b(%rip), %rax # 0x30145
movzbl (%rax), %edi
je 0x13872
cmpl $0x22, %edi
ja 0x13804
movl %edi, %eax
movabsq $0x400002400, %rcx # imm = 0x400002400
btq %rax, %rcx
jae 0x13804
movl $0x0, 0x1c950(%rip) # 0x30154
callq 0x1030
jmp 0x13998
leaq 0xc92b(%rip), %rbp # 0x20140
movzwl %bx, %eax
movw $0x0, (%rbp,%rax)
movq (%rsp), %rdi
callq 0x1120
addl $0x2, %ebx
leaq 0x1c913(%rip), %r12 # 0x30145
leaq 0x1c909(%rip), %rax # 0x30142
movb %bl, (%rax)
leaq 0x1c906(%rip), %rax # 0x30148
movb %bh, (%rax)
xorl %r13d, %r13d
xorl %r14d, %r14d
leaq 0x1c8f5(%rip), %rax # 0x30146
movb %r13b, (%rax)
movb %r14b, (%r12)
jmp 0x13595
cmpb $0xa, %al
jne 0x1358b
movb $0xd, (%rcx)
jmp 0x1358b
movb $0x5, %r14b
jmp 0x1384a
leal -0x81(%rdi), %eax
cmpl $0x1e, %eax
ja 0x13897
leaq 0x9f08(%rip), %rcx # 0x1d78c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x8, %edi
jmp 0x13993
leal -0xa(%rdi), %eax
cmpl $0x18, %eax
ja 0x138c3
leaq 0x9e82(%rip), %rcx # 0x1d728
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xd, %edi
callq 0x1030
movl $0xa, %edi
jmp 0x13804
cmpl $0x5, %edi
jne 0x13804
xorl %edi, %edi
jmp 0x13993
movl $0x6, %edi
jmp 0x13993
movl $0x7, %edi
jmp 0x13993
movl $0x5, %edi
jmp 0x13993
movl $0xf, %edi
jmp 0x13993
movl $0xe, %edi
jmp 0x13993
movl $0xb, %edi
jmp 0x13993
movl $0x9, %edi
jmp 0x13993
movl $0x4, %edi
jmp 0x13993
xorl %eax, %eax
callq 0x13ece
jmp 0x13998
xorl %eax, %eax
callq 0x13eb8
jmp 0x13998
movl $0xd, %edi
jmp 0x13993
movl $0xa, %edi
jmp 0x13993
xorl %edi, %edi
jmp 0x13961
xorl %eax, %eax
callq 0x13efa
jmp 0x13998
movl $0xc, %edi
jmp 0x13993
xorl %edi, %edi
xorl %esi, %esi
callq 0x13f26
jmp 0x13998
movl $0x1, %edi
callq 0x13f3d
jmp 0x13998
movl $0x3, %edi
jmp 0x13993
movl $0x1, 0x1c7db(%rip) # 0x30154
jmp 0x13804
movl $0x1, %edi
jmp 0x13993
xorl %eax, %eax
callq 0x13ee4
jmp 0x13998
movl $0x2, %edi
callq 0x13f61
movq 0xc641(%rip), %rax # 0x1ffe0
movq (%rax), %rdi
callq 0x11c0
jmp 0x1358b
xorl %eax, %eax
callq 0x13f10
jmp 0x13998
xorl %edi, %edi
callq 0x1200
leaq 0x1c785(%rip), %rax # 0x30148
movzbl (%rax), %esi
leaq 0x1c775(%rip), %rax # 0x30142
movzbl (%rax), %edx
leaq 0x9e87(%rip), %rdi # 0x1d85e
jmp 0x139f8
leaq 0x9e98(%rip), %rdi # 0x1d878
callq 0x1050
jmp 0x139ff
leaq 0xc73a(%rip), %rax # 0x20128
movzbl (%rax), %edx
leaq 0x9e25(%rip), %rdi # 0x1d81d
xorl %eax, %eax
callq 0x10c0
movl $0x1, %edi
callq 0x1200
nopl (%rax)
|
/workspace/github_c_makefile_star2_O3/mist64[P]cbmbasic/runtime.c
|
compare
|
int
compare(const char *s1) {
const unsigned char *s = (const unsigned char *)s1;
unsigned short chrptr = get_chrptr();
while (*s) {
CHRGET();
if (A != *s++) {
set_chrptr(chrptr);
return 0;
}
}
CHRGET();
return 1;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xc722(%rip), %r14 # 0x20140
movzwl 0x7a(%r14), %ebp
leaq 0x1c71b(%rip), %r15 # 0x30145
movb (%rbx), %r12b
callq 0x126e3
testb %r12b, %r12b
je 0x13a4e
movb (%r15), %al
leaq 0x1(%rbx), %rcx
cmpb (%rbx), %al
movq %rcx, %rbx
je 0x13a2a
movw %bp, 0x7a(%r14)
xorl %eax, %eax
jmp 0x13a53
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/mist64[P]cbmbasic/plugin.c
|
plugin_gone
|
unsigned short
plugin_gone() {
set_chrptr(get_chrptr()+1);
for (;;) {
unsigned short chrptr;
set_chrptr(get_chrptr()-1);
chrptr = get_chrptr();
/*
* this example shows:
* - how to get a 16 bit integer
* - how to get an 8 bit integer
* - how to check for a comma delimiter
* - how to do error handling
*/
if (compare("LOCATE")) {
unsigned char x,y;
y = get_byte(); /* 'line' first */
check_comma();
x = get_byte(); /* then 'column' */
/* XXX ignores terminal size */
if (x>80 || y>25 || x==0 || y==0)
return error(ERROR_ILLEGAL_QUANTITY);
move_cursor(x, y);
continue;
}
/* Implements the ANSI Set Graphics Mode
as appears on http://ascii-table.com/ansi-escape-sequences.php
Note that some attributes will be implemented differently depending on what
terminal program you are using.
*/
if (compare("ANSISGM")) {
char attr, fg, bg;
attr = get_byte(); /* Attribute */
check_comma();
fg = get_byte(); /* Foreground color */
check_comma();
bg = get_byte(); /* Background color */
if (attr < 0 || attr > 8) return error(ERROR_ILLEGAL_QUANTITY);
if (fg < 30 || fg > 37) return error(ERROR_ILLEGAL_QUANTITY);
if (bg < 40 || bg > 47) return error(ERROR_ILLEGAL_QUANTITY);
printf("\033[%d;%d;%dm",attr,bg,fg);
continue;
}
/* ANSI erase line */
if (compare("ANSIEL")) {
printf("\033[K");
}
/* ANSI save cursor pos */
if (compare("ANSISC")) {
printf("\033[s");
}
/* ANSI restore cursor pos */
if (compare("ANSIRC")) {
printf("\033[u");
}
/*
* this example shows:
* - how to override existing keywords
* - how to hand the instruction to the
* original interpreter if we don't want
* to handle it
*/
if (compare("\222")) { /* 0x92 - WAIT */
unsigned short a;
unsigned char b;
a = get_word();
check_comma();
b = get_byte();
if (a==6502) {
printf("MICROSOFT!");
continue;
} else {
set_chrptr(chrptr);
return 0;
}
}
/*
* this example shows:
* - how to deal with new keywords that contain
* existing keywords
* - how to parse a string
*/
if (compare("\236TEM")) {
char s[256];
get_string(s);
system(s);
continue;
}
if (compare("QUIT")) {
exit(0);
}
break;
}
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
leaq 0xc6c0(%rip), %rbp # 0x20140
incw 0x7a(%rbp)
leaq 0x9e00(%rip), %r13 # 0x1d88b
leaq 0xc696(%rip), %r15 # 0x20128
movzwl 0x7a(%rbp), %r12d
decl %r12d
movw %r12w, 0x7a(%rbp)
movq %r13, %rdi
callq 0x13a0c
testl %eax, %eax
je 0x13b18
callq 0x13e68
movl %eax, %r12d
leaq 0x1c686(%rip), %rax # 0x30140
movw $0xaefd, (%rax) # imm = 0xAEFD
movzbl (%r15), %eax
leal -0x1(%rax), %ecx
movb $-0x1, 0x100(%rbp,%rax)
addl $-0x2, %eax
movb %al, (%r15)
movzbl %cl, %eax
movb $-0x2, 0x100(%rbp,%rax)
xorl %edi, %edi
xorl %esi, %esi
callq 0x132c
callq 0x13e68
leal -0x51(%rax), %ecx
cmpb $-0x50, %cl
jb 0x13e23
leal -0x1a(%r12), %ecx
cmpb $-0x1a, %cl
jbe 0x13e23
movzbl %r12b, %esi
movzbl %al, %edi
callq 0x13f26
jmp 0x13a92
leaq 0x9d73(%rip), %rdi # 0x1d892
callq 0x13a0c
testl %eax, %eax
je 0x13c09
callq 0x13e68
movl %eax, %r12d
leaq 0x1c605(%rip), %rbx # 0x30140
movw $0xaefd, %ax # imm = 0xAEFD
movw %ax, (%rbx)
movzbl (%r15), %eax
leal -0x1(%rax), %ecx
movb $-0x1, %r15b
movb %r15b, 0x100(%rbp,%rax)
movb $-0x2, %r14b
addl %r14d, %eax
leaq 0xc5c7(%rip), %rdx # 0x20128
movb %al, (%rdx)
movzbl %cl, %eax
movb %r14b, 0x100(%rbp,%rax)
xorl %edi, %edi
xorl %esi, %esi
callq 0x132c
callq 0x13e68
movl %eax, %r13d
movw $0xaefd, %ax # imm = 0xAEFD
movw %ax, (%rbx)
leaq 0xc59b(%rip), %rax # 0x20128
movzbl (%rax), %eax
leal -0x1(%rax), %ecx
movb %r15b, 0x100(%rbp,%rax)
leaq 0xc586(%rip), %r15 # 0x20128
addl %r14d, %eax
movb %al, (%r15)
movzbl %cl, %eax
movb %r14b, 0x100(%rbp,%rax)
xorl %edi, %edi
xorl %esi, %esi
callq 0x132c
callq 0x13e68
cmpb $0x9, %r12b
jae 0x13e23
leal -0x26(%r13), %ecx
cmpb $-0x9, %cl
jbe 0x13e23
leal -0x30(%rax), %ecx
cmpb $-0x9, %cl
jbe 0x13e23
movsbl %r12b, %esi
movsbl %r13b, %ecx
movzbl %al, %edx
leaq 0x9ca4(%rip), %rdi # 0x1d89a
xorl %eax, %eax
callq 0x10c0
leaq 0x9c87(%rip), %r13 # 0x1d88b
jmp 0x13a92
leaq 0x9c96(%rip), %rdi # 0x1d8a6
callq 0x13a0c
testl %eax, %eax
je 0x13c27
leaq 0x9c8d(%rip), %rdi # 0x1d8ad
xorl %eax, %eax
callq 0x10c0
leaq 0x9c83(%rip), %rdi # 0x1d8b1
callq 0x13a0c
testl %eax, %eax
movq %rsp, %r13
je 0x13c48
leaq 0x9c77(%rip), %rdi # 0x1d8b8
xorl %eax, %eax
callq 0x10c0
leaq 0x9c6d(%rip), %rdi # 0x1d8bc
callq 0x13a0c
testl %eax, %eax
je 0x13c66
leaq 0x9c64(%rip), %rdi # 0x1d8c3
xorl %eax, %eax
callq 0x10c0
leaq 0x9c5a(%rip), %rdi # 0x1d8c7
callq 0x13a0c
testl %eax, %eax
jne 0x13d62
leaq 0x9c53(%rip), %rdi # 0x1d8d4
callq 0x13a0c
testl %eax, %eax
je 0x13e4a
leaq 0x1c4ab(%rip), %rbx # 0x30140
movw $0xad9e, (%rbx) # imm = 0xAD9E
movzbl (%r15), %eax
leal -0x1(%rax), %ecx
movb $-0x1, %r15b
movb %r15b, 0x100(%rbp,%rax)
movb $-0x2, %r14b
addl %r14d, %eax
leaq 0xc46f(%rip), %rdx # 0x20128
movb %al, (%rdx)
movzbl %cl, %eax
movb %r14b, 0x100(%rbp,%rax)
xorl %edi, %edi
xorl %esi, %esi
callq 0x132c
movw $0xb6a3, (%rbx) # imm = 0xB6A3
leaq 0xc44d(%rip), %rax # 0x20128
movzbl (%rax), %eax
leal -0x1(%rax), %ecx
movb %r15b, 0x100(%rbp,%rax)
leaq 0xc438(%rip), %r15 # 0x20128
addl %r14d, %eax
movb %al, (%r15)
movzbl %cl, %eax
movb %r14b, 0x100(%rbp,%rax)
xorl %edi, %edi
xorl %esi, %esi
callq 0x132c
leaq 0x1c434(%rip), %rax # 0x30145
movzbl (%rax), %r12d
movl $0x0, %eax
testq %r12, %r12
je 0x13d4a
leaq 0x1c41c(%rip), %rax # 0x30142
movzbl (%rax), %eax
leaq 0x1c418(%rip), %rcx # 0x30148
movzbl (%rcx), %esi
shll $0x8, %esi
orq %rax, %rsi
addq %rbp, %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x1180
movq %r12, %rax
movb $0x0, (%rsp,%rax)
movq %r13, %rdi
callq 0x10b0
leaq 0x9b2e(%rip), %r13 # 0x1d88b
jmp 0x13a92
leaq 0x1c3d7(%rip), %rbx # 0x30140
movw $0xad8a, (%rbx) # imm = 0xAD8A
movzbl (%r15), %eax
leal -0x1(%rax), %ecx
movb $-0x1, %dl
movb %dl, 0x100(%rbp,%rax)
movb $-0x1, %r13b
movq %r15, %r14
movb $-0x2, %r15b
addl %r15d, %eax
movb %al, (%r14)
movzbl %cl, %eax
movb %r15b, 0x100(%rbp,%rax)
xorl %edi, %edi
xorl %esi, %esi
callq 0x132c
movw $0xb7f7, (%rbx) # imm = 0xB7F7
movzbl (%r14), %eax
leal -0x1(%rax), %ecx
movb %r13b, 0x100(%rbp,%rax)
addl %r15d, %eax
movb %al, (%r14)
movzbl %cl, %eax
movb %r15b, 0x100(%rbp,%rax)
xorl %edi, %edi
xorl %esi, %esi
callq 0x132c
movzwl 0x14(%rbp), %r13d
movw $0xaefd, (%rbx) # imm = 0xAEFD
movzbl (%r14), %eax
leal -0x1(%rax), %ecx
movb $-0x1, %dl
movb %dl, 0x100(%rbp,%rax)
addl %r15d, %eax
movb %al, (%r14)
movzbl %cl, %eax
movb %r15b, 0x100(%rbp,%rax)
xorl %edi, %edi
xorl %esi, %esi
callq 0x132c
callq 0x13e68
cmpw $0x1966, %r13w # imm = 0x1966
jne 0x13e43
leaq 0x9ab2(%rip), %rdi # 0x1d8c9
xorl %eax, %eax
callq 0x10c0
jmp 0x13a84
leaq 0x1c318(%rip), %rax # 0x30142
movb $0xe, (%rax)
movw $0xa437, %ax # imm = 0xA437
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movw %r12w, 0x7a(%rbp)
jmp 0x13e5a
leaq 0x9a88(%rip), %rdi # 0x1d8d9
callq 0x13a0c
testl %eax, %eax
jne 0x13e5e
xorl %eax, %eax
jmp 0x13e31
xorl %edi, %edi
callq 0x1200
|
/workspace/github_c_makefile_star2_O3/mist64[P]cbmbasic/plugin.c
|
perftest
|
static int
perftest(void)
{
struct perftest_cookie_aes pca_actual;
struct perftest_cookie_aes * pca = &pca_actual;
uint8_t ciphertext_arr[16];
size_t keylen;
/* Sanity check. */
#ifdef CPUSUPPORT_X86_AESNI
if (cpusupport_x86_aesni()) {
if (crypto_aes_can_use_intrinsics() != 1) {
warn0("Unexpected error with AESNI");
goto err0;
}
}
#endif
/* Inform user about the hardware optimization status. */
print_hardware("Performance test of AES");
fflush(stdout);
/* Prepare arrays. */
if (parse_testcase(perftestcase, &pca->key_exp, &keylen,
pca->plaintext_arr, ciphertext_arr)) {
warn0("parse_testcase");
goto err0;
}
/* Time the function. */
if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
nbytes_warmup, 1, perftest_init, perftest_func, NULL, pca)) {
warn0("perftest_buffers");
goto err1;
}
/* Clean up. */
crypto_aes_key_free(pca->key_exp);
/* Success! */
return (0);
err1:
crypto_aes_key_free(pca->key_exp);
err0:
/* Failure! */
return (1);
}
|
pushq %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x590f(%rip), %rbx # 0x721c
cmpl $0x0, (%rbx)
je 0x1925
callq 0x1f14
cmpl $0x1, %eax
je 0x1936
leaq 0x26e7(%rip), %rdi # 0x400a
jmp 0x198f
leaq 0x58f4(%rip), %r14 # 0x7220
cmpl $0x0, (%r14)
je 0x1a1f
leaq 0x26e9(%rip), %rdi # 0x4026
callq 0x1c41
movq 0x56a7(%rip), %rax # 0x6ff0
movq (%rax), %rdi
callq 0x1200
leaq 0x28(%rsp), %rdx
movq 0x5433(%rip), %rax # 0x6d90
movq %rax, 0x10(%rsp)
movups 0x5417(%rip), %xmm0 # 0x6d80
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rbx
leaq 0x38(%rsp), %rsi
leaq 0x40(%rsp), %rcx
movq %rbx, %rdi
callq 0x1ca1
testl %eax, %eax
je 0x19b0
leaq 0x26af(%rip), %rdi # 0x403e
xorl %eax, %eax
callq 0x34ff
callq 0x1190
movl $0x0, (%rax)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rbx, 0x10(%rsp)
leaq 0x491(%rip), %rax # 0x1e4d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
leaq 0x2938(%rip), %rsi # 0x4308
leaq 0x446(%rip), %r9 # 0x1e1d
movl $0x1, %ebx
movl $0x40000000, %edi # imm = 0x40000000
movl $0x1, %edx
movl $0x9896800, %ecx # imm = 0x9896800
movl $0x1, %r8d
callq 0x2f64
testl %eax, %eax
je 0x1a3a
leaq 0x264c(%rip), %rdi # 0x404d
xorl %eax, %eax
callq 0x34ff
callq 0x1190
movl $0x0, (%rax)
movq 0x20(%rsp), %rdi
callq 0x207f
jmp 0x19a6
callq 0x1eec
movl %eax, (%rbx)
movl $0x1, (%r14)
testl %eax, %eax
jne 0x1912
jmp 0x1936
movq 0x20(%rsp), %rdi
callq 0x207f
xorl %ebx, %ebx
jmp 0x19a6
|
/workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/crypto_aes/main.c
|
selftest
|
static int
selftest(void)
{
struct crypto_aes_key * key_exp;
uint8_t plaintext_arr[MAX_PLAINTEXT_LENGTH];
uint8_t ciphertext_arr[MAX_PLAINTEXT_LENGTH];
uint8_t cbuf[MAX_PLAINTEXT_LENGTH];
size_t keylen;
size_t i;
size_t failures = 0;
size_t num_tests = sizeof(tests) / sizeof(tests[0]);
#ifdef CPUSUPPORT_X86_AESNI
__m128i bufsse;
#endif
#ifdef CPUSUPPORT_ARM_AES
uint8x16_t bufarm;
#endif
/* Sanity check. */
#ifdef CPUSUPPORT_X86_AESNI
if (cpusupport_x86_aesni()) {
if (crypto_aes_can_use_intrinsics() != 1) {
warn0("Unexpected error with AESNI");
goto err0;
}
}
#endif
/* Inform user about the hardware optimization status. */
print_hardware("Checking test vectors of AES");
/* Run regular test cases. */
for (i = 0; i < num_tests; i++) {
/* Prepare for the test case. */
if (parse_testcase(tests[i], &key_exp, &keylen,
plaintext_arr, ciphertext_arr)) {
warn0("parse_testcase");
goto err0;
}
printf("Computing %zu-bit AES of \"%s\"...",
keylen * 8, tests[i].plaintext_hex);
/* Run AES. */
#ifdef CPUSUPPORT_X86_AESNI
if (crypto_aes_can_use_intrinsics() == 1) {
bufsse = _mm_loadu_si128(
(const __m128i *)plaintext_arr);
bufsse = crypto_aes_encrypt_block_aesni_m128i(bufsse,
key_exp);
_mm_storeu_si128((__m128i *)cbuf, bufsse);
} else
#endif
#ifdef CPUSUPPORT_ARM_AES
if (crypto_aes_can_use_intrinsics() == 2) {
bufarm = vld1q_u8(plaintext_arr);
bufarm = crypto_aes_encrypt_block_arm_u8(bufarm,
key_exp);
vst1q_u8(cbuf, bufarm);
} else
#endif
crypto_aes_encrypt_block(plaintext_arr, cbuf, key_exp);
/* Check result. */
if (memcmp(cbuf, ciphertext_arr, 16)) {
printf(" FAILED!\n");
print_arr("Computed AES:\t", cbuf, 16);
print_arr("Correct AES:\t", ciphertext_arr, 16);
failures++;
} else {
printf(" PASSED!\n");
}
/* Clean up. */
crypto_aes_key_free(key_exp);
}
/* Report overall success to exit code. */
if (failures)
return (1);
else
return (0);
err0:
/* Failure! */
return (1);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x57bc(%rip), %rbx # 0x721c
cmpl $0x0, (%rbx)
je 0x1a7b
callq 0x1f14
cmpl $0x1, %eax
je 0x1a8c
leaq 0x2594(%rip), %rdi # 0x400a
jmp 0x1bbc
leaq 0x579e(%rip), %r14 # 0x7220
cmpl $0x0, (%r14)
je 0x1be2
leaq 0x273d(%rip), %rdi # 0x41d0
callq 0x1c41
movb $0x1, %bpl
leaq 0x52fe(%rip), %r14 # 0x6da0
leaq 0x50(%rsp), %r15
leaq 0x40(%rsp), %r12
xorl %eax, %eax
xorl %r13d, %r13d
leaq (%rax,%rax,2), %rax
movq 0x10(%r14,%rax,8), %rcx
movq %rcx, 0x10(%rsp)
movups (%r14,%rax,8), %xmm0
movups %xmm0, (%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1ca1
testl %eax, %eax
jne 0x1bb5
movq 0x38(%rsp), %rsi
shlq $0x3, %rsi
leaq 0x26f8(%rip), %rdi # 0x41ed
leaq 0x2658(%rip), %rdx # 0x4154
xorl %eax, %eax
callq 0x1030
callq 0x1f14
cmpl $0x1, %eax
jne 0x1b26
movaps 0x50(%rsp), %xmm0
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x2709
movaps %xmm0, 0x20(%rsp)
jmp 0x1b3b
movq 0x18(%rsp), %rbx
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x206d
movdqa 0x20(%rsp), %xmm0
pcmpeqb 0x40(%rsp), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x1b83
leaq 0x2779(%rip), %rdi # 0x42d2
callq 0x1070
leaq 0x26a9(%rip), %rdi # 0x420e
leaq 0x20(%rsp), %rsi
callq 0x1e9f
leaq 0x26a7(%rip), %rdi # 0x421d
movq %r12, %rsi
callq 0x1e9f
incq %r13
jmp 0x1b8f
leaq 0x273f(%rip), %rdi # 0x42c9
callq 0x1070
movq %rbx, %rdi
callq 0x207f
movl $0x1, %eax
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x1ab1
xorl %eax, %eax
testq %r13, %r13
setne %al
jmp 0x1bd3
leaq 0x2482(%rip), %rdi # 0x403e
xorl %eax, %eax
callq 0x34ff
callq 0x1190
movl $0x0, (%rax)
movl $0x1, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1eec
movl %eax, (%rbx)
movl $0x1, (%r14)
testl %eax, %eax
jne 0x1a65
jmp 0x1a8c
|
/workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/crypto_aes/main.c
|
parse_testcase
|
static int
parse_testcase(const struct testcase testcase,
struct crypto_aes_key ** key_exp_p, size_t * keylen_p,
uint8_t plaintext_arr[static MAX_PLAINTEXT_LENGTH],
uint8_t ciphertext_arr[static MAX_PLAINTEXT_LENGTH])
{
uint8_t key_unexpanded[32]; /* We will use 16 or 32 of these bytes. */
const size_t len = strlen(testcase.plaintext_hex) / 2;
/* Determine key length. */
*keylen_p = strlen(testcase.keytext_hex) / 2;
/* Sanity check. */
assert((*keylen_p == 16) || (*keylen_p == 32));
assert(len == 16);
/* Prepare the key. */
if (unhexify(testcase.keytext_hex, key_unexpanded, *keylen_p)) {
warn0("unhexify(%s)", testcase.keytext_hex);
goto err0;
}
if ((*key_exp_p = crypto_aes_key_expand(key_unexpanded, *keylen_p))
== NULL) {
warn0("crypto_aes_key_expand");
goto err0;
}
/* Prepare the arrays. */
if (unhexify(testcase.plaintext_hex, plaintext_arr, len)) {
warn0("unhexify(%s)", testcase.plaintext_hex);
goto err1;
}
if (unhexify(testcase.ciphertext_hex, ciphertext_arr, len)) {
warn0("unhexify(%s)", testcase.ciphertext_hex);
goto err1;
}
/* Clean up. Irrelevant for a test, but it's a good habit. */
insecure_memzero(key_unexpanded, 32);
/* Success! */
return (0);
err1:
crypto_aes_key_free(*key_exp_p);
err0:
/* Failure! */
return (1);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x78(%rsp), %r14
movq %r14, %rdi
callq 0x1120
movq %rax, %r15
movq 0x70(%rsp), %rbp
movq %rbp, %rdi
callq 0x1120
shrq %rax
movq %rax, (%r13)
cmpq $0x10, %rax
je 0x1cf1
cmpq $0x20, %rax
jne 0x1dfe
andq $-0x2, %r15
cmpq $0x20, %r15
jne 0x1ddf
leaq 0x10(%rsp), %rsi
movq %rbp, %rdi
movq %rax, %rdx
callq 0x2ea3
testl %eax, %eax
je 0x1d31
leaq 0x23d6(%rip), %rdi # 0x40f0
movq %rbp, %rsi
xorl %eax, %eax
callq 0x34ff
callq 0x1190
movl $0x0, (%rax)
jmp 0x1d9e
movq (%r13), %rsi
leaq 0x10(%rsp), %rdi
callq 0x1fdf
movq %rax, (%rbx)
testq %rax, %rax
je 0x1db2
movl $0x10, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2ea3
testl %eax, %eax
jne 0x1d7a
leaq 0x70(%rsp), %rax
movq 0x10(%rax), %r14
movl $0x10, %edx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x2ea3
testl %eax, %eax
je 0x1dc5
leaq 0x236f(%rip), %rdi # 0x40f0
movq %r14, %rsi
xorl %eax, %eax
callq 0x34ff
callq 0x1190
movl $0x0, (%rax)
movq (%rbx), %rdi
callq 0x207f
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2344(%rip), %rdi # 0x40fd
xorl %eax, %eax
callq 0x34ff
jmp 0x1d24
leaq 0x543c(%rip), %rax # 0x7208
movq (%rax), %rax
leaq 0x10(%rsp), %rdi
movl $0x20, %esi
callq *%rax
xorl %eax, %eax
jmp 0x1da3
leaq 0x23b3(%rip), %rdi # 0x4199
leaq 0x2298(%rip), %rsi # 0x4085
leaq 0x2298(%rip), %rcx # 0x408c
movl $0x7e, %edx
callq 0x1090
leaq 0x2259(%rip), %rdi # 0x405e
leaq 0x2279(%rip), %rsi # 0x4085
leaq 0x2279(%rip), %rcx # 0x408c
movl $0x7d, %edx
callq 0x1090
|
/workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/crypto_aes/main.c
|
mtgp32_init_state
|
void mtgp32_init_state(uint32_t array[],
const mtgp32_params_fast_t *para, uint32_t seed) {
int i;
int size = para->mexp / 32 + 1;
uint32_t hidden_seed;
uint32_t tmp;
hidden_seed = para->tbl[4] ^ (para->tbl[8] << 16);
tmp = hidden_seed;
tmp += tmp >> 16;
tmp += tmp >> 8;
memset(array, tmp & 0xff, sizeof(uint32_t) * size);
array[0] = seed;
array[1] = hidden_seed;
for (i = 1; i < size; i++) {
array[i] ^= UINT32_C(1812433253) * (array[i - 1]
^ (array[i - 1] >> 30))
+ i;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
movl (%rsi), %r15d
movl 0x30(%rsi), %r12d
leal 0x1f(%r15), %r14d
testl %r15d, %r15d
cmovnsl %r15d, %r14d
sarl $0x5, %r14d
shll $0x10, %r12d
xorl 0x20(%rsi), %r12d
movl %r12d, %eax
shrl $0x10, %eax
addl %r12d, %eax
movl %eax, %esi
shrl $0x8, %esi
addl %eax, %esi
movslq %r14d, %rax
leaq 0x4(,%rax,4), %rdx
callq 0x1090
movl %ebp, (%rbx)
movl %r12d, 0x4(%rbx)
cmpl $0x20, %r15d
jl 0x133b
incl %r14d
movl %r14d, %eax
movl (%rbx), %ecx
movl $0x1, %edx
movl %ecx, %esi
shrl $0x1e, %esi
xorl %ecx, %esi
imull $0x6c078965, %esi, %ecx # imm = 0x6C078965
addl %edx, %ecx
xorl (%rbx,%rdx,4), %ecx
movl %ecx, (%rbx,%rdx,4)
incq %rdx
cmpq %rdx, %rax
jne 0x131e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
|
mtgp32_init_by_array
|
int mtgp32_init_by_array(mtgp32_fast_t *mtgp32,
const mtgp32_params_fast_t *para,
uint32_t *array, int length) {
int i, j, count;
uint32_t r;
int lag;
int mid;
int size = para->mexp / 32 + 1;
uint32_t hidden_seed;
uint32_t tmp;
mtgp32_status_fast_t *st;
int rc;
rc = alloc_state(mtgp32, para);
if (rc) {
return rc;
}
st = mtgp32->status;
if (size >= 623) {
lag = 11;
} else if (size >= 68) {
lag = 7;
} else if (size >= 39) {
lag = 5;
} else {
lag = 3;
}
mid = (size - lag) / 2;
hidden_seed = para->tbl[4] ^ (para->tbl[8] << 16);
tmp = hidden_seed;
tmp += tmp >> 16;
tmp += tmp >> 8;
memset(st->array, tmp & 0xff, sizeof(uint32_t) * size);
mtgp32->params = *para;
mtgp32->status = st;
st->size = size;
st->idx = size - 1;
st->array[0] = hidden_seed;
if (length + 1 > size) {
count = length + 1;
} else {
count = size;
}
r = ini_func1(st->array[0] ^ st->array[mid] ^ st->array[size - 1]);
st->array[mid] += r;
r += length;
st->array[(mid + lag) % size] += r;
st->array[0] = r;
i = 1;
count--;
for (i = 1, j = 0; (j < count) && (j < length); j++) {
r = ini_func1(st->array[i] ^ st->array[(i + mid) % size]
^ st->array[(i + size - 1) % size]);
st->array[(i + mid) % size] += r;
r += array[j] + i;
st->array[(i + mid + lag) % size] += r;
st->array[i] = r;
i = (i + 1) % size;
}
for (; j < count; j++) {
r = ini_func1(st->array[i] ^ st->array[(i + mid) % size]
^ st->array[(i + size - 1) % size]);
st->array[(i + mid) % size] += r;
r += i;
st->array[(i + mid + lag) % size] += r;
st->array[i] = r;
i = (i + 1) % size;
}
for (j = 0; j < size; j++) {
r = ini_func2(st->array[i] + st->array[(i + mid) % size]
+ st->array[(i + size - 1) % size]);
st->array[(i + mid) % size] ^= r;
r -= i;
st->array[(i + mid + lag) % size] ^= r;
st->array[i] = r;
i = (i + 1) % size;
}
if (st->array[size - 1] == 0) {
st->array[size - 1] = non_zero;
}
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl (%rsi), %ebx
leal 0x1f(%rbx), %r13d
testl %ebx, %ebx
cmovnsl %ebx, %r13d
callq 0x122d
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x162b
movq %r14, 0x20(%rsp)
movl %ebp, 0x4(%rsp)
sarl $0x5, %r13d
leal 0x1(%r13), %ebp
movq %r15, 0x8(%rsp)
movq 0xf0(%r15), %r15
movl $0xb, %edx
cmpl $0x4dbf, %ebx # imm = 0x4DBF
jg 0x13c6
movl $0x7, %edx
cmpl $0x85f, %ebx # imm = 0x85F
jg 0x13c6
xorl %eax, %eax
cmpl $0x4c0, %ebx # imm = 0x4C0
setge %al
leal 0x3(,%rax,2), %edx
movl %edx, 0x1c(%rsp)
movq %rbx, 0x30(%rsp)
movl %ebp, %eax
subl %edx, %eax
movl %eax, %r14d
shrl $0x1f, %r14d
addl %eax, %r14d
sarl %r14d
movq %r12, %rax
movq %r12, 0x10(%rsp)
movl 0x30(%r12), %r12d
shll $0x10, %r12d
xorl 0x20(%rax), %r12d
movl %r12d, %eax
shrl $0x10, %eax
addl %r12d, %eax
movl %eax, %esi
shrl $0x8, %esi
addl %eax, %esi
leaq 0x10(%r15), %rbx
movslq %ebp, %rax
movq %rax, 0x28(%rsp)
leaq (,%rax,4), %rdx
movq %rbx, %rdi
callq 0x1090
movl $0xec, %edx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x10d0
movq 0x8(%rsp), %rax
movq %r15, 0xf0(%rax)
movq 0x28(%rsp), %r9
movl %r9d, 0x4(%r15)
movl %r13d, (%r15)
movl %r12d, 0x10(%r15)
movl 0x4(%rsp), %esi
cmpl %esi, %r13d
movl %esi, %edi
cmovgl %r13d, %edi
movslq %r14d, %rax
movl 0x10(%r15,%rax,4), %ecx
movslq %r13d, %r11
xorl 0x10(%r15,%r11,4), %r12d
xorl %ecx, %r12d
movl %r12d, %edx
shrl $0x1b, %edx
xorl %r12d, %edx
movl 0x1c(%rsp), %r12d
imull $0x19660d, %edx, %r8d # imm = 0x19660D
addl %r8d, %ecx
movl %ecx, 0x10(%r15,%rax,4)
addl %esi, %r8d
addl %r12d, %eax
cltd
idivl %r9d
movslq %edx, %rax
addl %r8d, 0x10(%r15,%rax,4)
movl %r8d, 0x10(%r15)
testl %esi, %esi
jle 0x154b
movq %r11, 0x10(%rsp)
movl %esi, %eax
movq %rax, 0x8(%rsp)
movl $0x1, %edx
xorl %r9d, %r9d
movq %r14, %r8
movq %r13, %r14
movl %r12d, %r13d
movq 0x20(%rsp), %r15
movslq %edx, %r10
movl (%rbx,%r10,4), %r11d
leal (%r10,%r8), %ecx
movl %ecx, %eax
cltd
idivl %ebp
movslq %edx, %r12
movl (%rbx,%r12,4), %esi
leal (%r10,%r14), %eax
cltd
idivl %ebp
movslq %edx, %rax
xorl (%rbx,%rax,4), %r11d
xorl %esi, %r11d
movl %r11d, %eax
shrl $0x1b, %eax
xorl %r11d, %eax
imull $0x19660d, %eax, %eax # imm = 0x19660D
addl %eax, %esi
movl %esi, (%rbx,%r12,4)
movl (%r15,%r9,4), %esi
addl %r10d, %esi
addl %eax, %esi
addl %r13d, %ecx
movl %ecx, %eax
cltd
idivl %ebp
movslq %edx, %rax
addl %esi, (%rbx,%rax,4)
movl %esi, (%rbx,%r10,4)
leal 0x1(%r10), %eax
cltd
idivl %ebp
incq %r9
cmpq %r9, 0x8(%rsp)
jne 0x14ce
movq 0x10(%rsp), %r11
movl 0x4(%rsp), %eax
movl %r13d, %r12d
movq %r14, %r13
movq %r8, %r14
jmp 0x1552
movl $0x1, %edx
xorl %eax, %eax
subl %eax, %edi
jle 0x15b1
movslq %edx, %r8
movl (%rbx,%r8,4), %esi
leal (%r8,%r14), %ecx
movl %ecx, %eax
cltd
idivl %ebp
movslq %edx, %r9
movl (%rbx,%r9,4), %r10d
leal (%r8,%r13), %eax
cltd
idivl %ebp
movslq %edx, %rax
xorl (%rbx,%rax,4), %esi
xorl %r10d, %esi
movl %esi, %eax
shrl $0x1b, %eax
xorl %esi, %eax
imull $0x19660d, %eax, %esi # imm = 0x19660D
addl %esi, %r10d
movl %r10d, (%rbx,%r9,4)
addl %r8d, %esi
addl %r12d, %ecx
movl %ecx, %eax
cltd
idivl %ebp
movslq %edx, %rax
addl %esi, (%rbx,%rax,4)
movl %esi, (%rbx,%r8,4)
leal 0x1(%r8), %eax
cltd
idivl %ebp
decl %edi
jne 0x1556
cmpl $-0x1f, 0x30(%rsp)
jl 0x161a
movl %ebp, %edi
movslq %edx, %r8
leal (%r8,%r14), %ecx
movl %ecx, %eax
cltd
idivl %ebp
movslq %edx, %rsi
movl (%rbx,%rsi,4), %r9d
movl (%rbx,%r8,4), %r10d
addl %r9d, %r10d
leal (%r8,%r13), %eax
cltd
idivl %ebp
movslq %edx, %rax
addl (%rbx,%rax,4), %r10d
movl %r10d, %eax
shrl $0x1b, %eax
xorl %r10d, %eax
imull $0x5d588b65, %eax, %r10d # imm = 0x5D588B65
xorl %r10d, %r9d
movl %r9d, (%rbx,%rsi,4)
subl %r8d, %r10d
addl %r12d, %ecx
movl %ecx, %eax
cltd
idivl %ebp
movslq %edx, %rax
xorl %r10d, (%rbx,%rax,4)
movl %r10d, (%rbx,%r8,4)
leal 0x1(%r8), %eax
cltd
idivl %ebp
decl %edi
jne 0x15ba
xorl %eax, %eax
cmpl $0x0, (%rbx,%r11,4)
jne 0x162b
movl $0x4d544750, (%rbx,%r11,4) # imm = 0x4D544750
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
|
mtgp32_print_idstring
|
void mtgp32_print_idstring(const mtgp32_fast_t *mtgp32, FILE *fp) {
int i;
fprintf(fp, "mtgp32:%d:", mtgp32->params.mexp);
for (i = 0; i < 20; i++) {
fprintf(fp, "%02x", (unsigned int)mtgp32->params.poly_sha1[i]);
}
fprintf(fp, "\n");
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edx
leaq 0x169a(%rip), %rsi # 0x300c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
leaq 0x1694(%rip), %r15 # 0x3017
xorl %r12d, %r12d
movzbl 0xd4(%r14,%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
incq %r12
cmpq $0x14, %r12
jne 0x1986
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10a0
|
/workspace/github_c_makefile_star2_O3/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
|
print_close_open
|
void print_close_open(mtgp32_fast_t *mtgp32, int count) {
int i;
for (i = 0; i < count; i++) {
printf("%.8f ", mtgp32_genrand_close_open(mtgp32));
if (i % 5 == 4) {
printf("\n");
}
}
if (i % 5 != 0) {
printf("\n");
}
}
|
testl %esi, %esi
jle 0x1da0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebp, %ebp
movl $0x4, %r12d
movl %esi, (%rsp)
movl %esi, 0x4(%rsp)
movl %ebp, %edx
movl $0xcccccccd, %eax # imm = 0xCCCCCCCD
imulq %rax, %rdx
shrq $0x22, %rdx
movq 0xf0(%r14), %rsi
movl 0x4(%rsi), %edi
movl 0x8(%rsi), %eax
movslq 0xc(%rsi), %r8
movslq (%rsi), %r10
incq %r10
andq %r8, %r10
movl 0x4(%r14), %r9d
addl %eax, %r9d
movl %r10d, (%rsi)
movl %r10d, %ecx
subl %edi, %ecx
leal (%rcx,%rax), %r11d
andl %r8d, %r11d
leal (%rcx,%rax), %r13d
incl %r13d
andl %r8d, %r13d
movl %r9d, %eax
subl %edi, %eax
addl %r10d, %eax
andl %r8d, %eax
movl 0x10(%rsi,%rax,4), %r15d
movb 0x8(%r14), %cl
movl 0xd0(%r14), %ebx
andl 0x10(%rsi,%r11,4), %ebx
movb 0xc(%r14), %al
xorl 0x10(%rsi,%r13,4), %ebx
movl %ebx, %r11d
shll %cl, %r11d
movl %eax, %ecx
shrl %cl, %r15d
xorl %ebx, %r15d
xorl %r11d, %r15d
movl %r15d, %eax
andl $0xf, %eax
xorl 0x10(%r14,%rax,4), %r15d
movl %r15d, 0x10(%rsi,%r10,4)
movslq (%rsi), %rax
movl 0x10(%rsi,%rax,4), %ecx
notl %edi
addl %r9d, %edi
addl %eax, %edi
andl %r8d, %edi
movl 0x10(%rsi,%rdi,4), %eax
movl %eax, %esi
shrl $0x10, %esi
xorl %eax, %esi
movl %esi, %eax
shrl $0x8, %eax
xorl %esi, %eax
shrl $0x9, %ecx
andl $0xf, %eax
xorl 0x90(%r14,%rax,4), %ecx
leal (%rdx,%rdx,4), %ebx
movd %ecx, %xmm0
addss 0x12bf(%rip), %xmm0 # 0x3004
cvtss2sd %xmm0, %xmm0
leaq 0x12d2(%rip), %rdi # 0x3022
movb $0x1, %al
callq 0x1080
addl %r12d, %ebx
jne 0x1d66
movl $0xa, %edi
callq 0x1040
incl %ebp
decl %r12d
movl 0x4(%rsp), %eax
decl %eax
movl %eax, %esi
jne 0x1c6e
imull $0xcccccccd, (%rsp), %eax # imm = 0xCCCCCCCD
cmpl $0x33333334, %eax # imm = 0x33333334
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jb 0x1da0
movl $0xa, %edi
jmp 0x1040
retq
|
/workspace/github_c_makefile_star2_O3/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
|
main
|
int main(int argc, char *argv[]) {
int mexp;
int no;
uint32_t seed = 1;
uint32_t seed_ar[4] = {1, 2, 3, 4};
char seed_str[] = "\01\02\03\04";
mtgp32_params_fast_t *params;
mtgp32_fast_t mtgp32;
int rc;
if (argc <= 2) {
printf("%s: mexp no.\n", argv[0]);
return 1;
}
mexp = strtol(argv[1], NULL, 10);
if (errno) {
printf("%s: mexp no.\n", argv[0]);
return 2;
}
no = strtol(argv[2], NULL, 10);
if (errno) {
printf("%s: mexp no.\n", argv[0]);
return 3;
}
switch (mexp) {
case 11213:
params = mtgp32_params_fast_11213;
break;
case 23209:
params = mtgp32_params_fast_23209;
break;
case 44497:
params = mtgp32_params_fast_44497;
break;
default:
printf("%s: mexp no.\n", argv[0]);
printf("mexp shuould be 11213, 23209 or 44497\n");
return 4;
}
if (no >= 128 || no < 0) {
printf("%s: mexp no.\n", argv[0]);
printf("no must be between 0 and 127\n");
return 5;
}
params += no;
rc = mtgp32_init(&mtgp32, params, seed);
if (rc) {
printf("failure in mtgp32_init\n");
return -1;
}
mtgp32_print_idstring(&mtgp32, stdout);
printf("init:\n");
print_uint32(&mtgp32, 1000);
mtgp32_free(&mtgp32);
rc = mtgp32_init_by_array(&mtgp32, params, seed_ar, 4);
if (rc) {
printf("failure in mtgp32_init_by_array\n");
return -1;
}
printf("init_array:\n");
print_uint32(&mtgp32, 1000);
mtgp32_free(&mtgp32);
rc = mtgp32_init_by_str(&mtgp32, params, seed_str);
if (rc) {
printf("failure in mtgp32_init_by_str\n");
return -1;
}
printf("init_str:\n");
print_uint32(&mtgp32, 1000);
print_close1_open2(&mtgp32, 1000);
print_close_open(&mtgp32, 1000);
print_open_close(&mtgp32, 1000);
print_open_open(&mtgp32, 1000);
mtgp32_free(&mtgp32);
return 0;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movq %rsi, %r14
cmpl $0x2, %edi
jg 0x207e
movq (%r14), %rsi
leaq 0xfc0(%rip), %rdi # 0x302d
xorl %eax, %eax
callq 0x1080
movl $0x1, %eax
jmp 0x2250
movq 0x8(%r14), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x10c0
movq %rax, %rbx
callq 0x1050
cmpl $0x0, (%rax)
je 0x20b6
movq (%r14), %rsi
leaq 0xf88(%rip), %rdi # 0x302d
xorl %eax, %eax
callq 0x1080
movl $0x2, %eax
jmp 0x2250
movq %rax, %r15
movq 0x10(%r14), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x10c0
cmpl $0x0, (%r15)
je 0x20ea
movq (%r14), %rsi
leaq 0xf54(%rip), %rdi # 0x302d
xorl %eax, %eax
callq 0x1080
movl $0x3, %eax
jmp 0x2250
cmpl $0x2bcd, %ebx # imm = 0x2BCD
je 0x2114
cmpl $0xadd1, %ebx # imm = 0xADD1
je 0x210b
cmpl $0x5aa9, %ebx # imm = 0x5AA9
jne 0x2178
leaq 0xa587(%rip), %rbx # 0xc690
jmp 0x211b
leaq 0x11b7e(%rip), %rbx # 0x13c90
jmp 0x211b
leaq 0x2f75(%rip), %rbx # 0x5090
testl $0xffffff80, %eax # imm = 0xFFFFFF80
je 0x2149
movq (%r14), %rsi
leaq 0xf01(%rip), %rdi # 0x302d
xorl %eax, %eax
callq 0x1080
leaq 0xf72(%rip), %rdi # 0x30ac
callq 0x1060
movl $0x5, %eax
jmp 0x2250
andl $0x7f, %eax
imulq $0xec, %rax, %rax
addq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x11ec
testl %eax, %eax
je 0x219f
leaq 0xf22(%rip), %rdi # 0x3095
jmp 0x2246
movq (%r14), %rsi
leaq 0xeab(%rip), %rdi # 0x302d
xorl %eax, %eax
callq 0x1080
leaq 0xf39(%rip), %rdi # 0x30c9
callq 0x1060
movl $0x4, %eax
jmp 0x2250
movq 0x2e3a(%rip), %rax # 0x4fe0
movq (%rax), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x195b
leaq 0xe7e(%rip), %rdi # 0x303b
callq 0x1060
movq %r14, %rdi
movl $0x3e8, %esi # imm = 0x3E8
callq 0x19bd
movq 0xf0(%r14), %rdi
callq 0x1030
leaq 0xf0e(%rip), %rdx # 0x30f0
movq %r14, %rdi
movq %rbx, %rsi
movl $0x4, %ecx
callq 0x1344
testl %eax, %eax
je 0x21ff
leaq 0xe78(%rip), %rdi # 0x3075
jmp 0x2246
leaq 0xe3b(%rip), %rdi # 0x3041
callq 0x1060
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3e8, %esi # imm = 0x3E8
callq 0x19bd
movq 0xf0(%r14), %rdi
callq 0x1030
leaq 0xdf8(%rip), %rdx # 0x3028
movq %r14, %rdi
movq %rbx, %rsi
callq 0x163a
testl %eax, %eax
je 0x225d
leaq 0xe11(%rip), %rdi # 0x3057
callq 0x1060
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x100, %rsp # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
leaq 0xde9(%rip), %rdi # 0x304d
callq 0x1060
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi # imm = 0x3E8
callq 0x19bd
movq %rbx, %rdi
movl $0x3e8, %esi # imm = 0x3E8
callq 0x1af9
movq %rbx, %rdi
movl $0x3e8, %esi # imm = 0x3E8
callq 0x1c4d
movq %rbx, %rdi
movl $0x3e8, %esi # imm = 0x3E8
callq 0x1da1
movq %rbx, %rdi
movl $0x3e8, %esi # imm = 0x3E8
callq 0x1efa
movq 0xf0(%rbx), %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x2250
nop
|
/workspace/github_c_makefile_star2_O3/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
|
main
|
int main(int argc, char **argv) {
if (argc > 1) {
if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
printf("hostname [-s] <hostname>\n");
printf("No arguments prints hostname\n");
} else if (strcmp(argv[1], "-s") == 0) {
const char *hostname = argv[2];
int err = sethostname(hostname, strlen(hostname));
if (err != 0) {
printf("Error setting hostname\n");
return 1;
} else {
printf("Hostname set.\n");
return 0;
}
}
} else {
char hostname[HOST_NAME_MAX + 1];
int err = gethostname(hostname, HOST_NAME_MAX + 1);
if (err != 0) {
printf("Error getting hostname.\n");
return 1;
} else {
printf("%s\n", hostname);
return 0;
}
}
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpl $0x2, %edi
jl 0x120e
movq %rsi, %r14
movq 0x8(%rsi), %r15
cmpb $0x2d, (%r15)
jne 0x1237
cmpb $0x68, 0x1(%r15)
jne 0x11b1
cmpb $0x0, 0x2(%r15)
je 0x124c
leaq 0xe4c(%rip), %rsi # 0x2004
movq %r15, %rdi
callq 0x1050
testl %eax, %eax
je 0x124c
xorl %ebx, %ebx
cmpb $0x73, 0x1(%r15)
jne 0x1266
cmpb $0x0, 0x2(%r15)
jne 0x1266
movq 0x10(%r14), %r14
movq %r14, %rdi
callq 0x1040
movq %r14, %rdi
movq %rax, %rsi
callq 0x1060
testl %eax, %eax
je 0x1272
leaq 0xe2f(%rip), %rdi # 0x2031
callq 0x1030
movl $0x1, %ebx
jmp 0x1266
movq %rsp, %r14
movl $0x41, %esi
movq %r14, %rdi
callq 0x1070
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
leaq 0xddf(%rip), %rdi # 0x200b
cmoveq %r14, %rdi
callq 0x1030
jmp 0x1266
leaq 0xdc6(%rip), %rsi # 0x2004
movq %r15, %rdi
callq 0x1050
xorl %ebx, %ebx
testl %eax, %eax
jne 0x1266
leaq 0xdf5(%rip), %rdi # 0x2048
callq 0x1030
leaq 0xe02(%rip), %rdi # 0x2061
callq 0x1030
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xdaa(%rip), %rdi # 0x2023
jmp 0x1230
|
/workspace/github_c_makefile_star2_O3/keiranrowan[P]tiny-core/./src/hostname.c
|
processLine
|
char *processLine( char *line ) {
char *retline = malloc( strlen(line)+1 );
int i, e = 0, modifier, letter;
for( i = 0; i < strlen(line) + 1; i++ ) {
if( line[i] != 0x26 ) { // &
retline[e] = line[i];
e++;
}
else {
i++;
modifier = line[i];
i++;
letter = line[i];
retline[e] = getModdedLetter( modifier, letter );
e++;
}
}
return retline;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1080
movq %rax, %r14
leaq 0x1(%rax), %rdi
callq 0x10c0
movq %rax, %r15
incq %r14
je 0x130d
xorl %eax, %eax
movq %r15, %r12
xorl %r13d, %r13d
movb (%rbx,%rax), %al
cmpb $0x26, %al
jne 0x12fb
movslq %r13d, %r13
movsbl 0x1(%rbx,%r13), %edi
movsbl 0x2(%rbx,%r13), %esi
addq $0x2, %r13
callq 0x122c
movb %al, (%r12)
incl %r13d
movslq %r13d, %rax
incq %r12
cmpq %rax, %r14
ja 0x12dc
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-zoe/subtitle-convert.c
|
main
|
int main( int argc, char **argv ) {
FILE *f, *o;
unsigned int fileSize, lineNumber = 1, lineHour, lineMinute, lineSecond, lineMs, jp = 0, bom = 0;
subLineHeader header;
char lineStartText[13] = { 0 }, lineEndText[13] = { 0 };
char *readline = NULL, *outputline = NULL;
if( argc < 2 ) {
printf("Not enough args!\nUse: %s subtitle file\n", argv[0]);
return 1;
}
if( !(f = fopen( argv[1], "rb" ))) {
printf("Couldnt open file %s\n", argv[1]);
return 1;
}
char *outputname = malloc( strlen( argv[1] ) + 4 + 1 );
sprintf( outputname, "%s.srt", argv[1] );
if( !(o = fopen( outputname, "wb" ))) {
printf("Couldnt open file %s\n", outputname);
return 1;
}
free(outputname);
fseek( f, 0, SEEK_END );
fileSize = ftell(f);
fseek( f, 0, SEEK_SET );
while( ftell(f) != fileSize ) {
fread( &header, sizeof(header), 1, f );
readline = malloc( header.textLength );
fread( readline, header.textLength, 1, f );
lineSecond = header.startFrame/60;
lineMinute = lineSecond/60;
lineHour = lineMinute/60;
lineMs = 1000 * ((float)header.startFrame/60 - lineSecond);
lineMinute -= 60*lineHour;
lineSecond -= 60*lineMinute;
sprintf( lineStartText, "%02d:%02d:%02d,%03d", lineHour, lineMinute, lineSecond, lineMs );
lineSecond = header.endFrame/60;
lineMinute = lineSecond/60;
lineHour = lineMinute/60;
lineMs = 1000 * ((float)header.endFrame/60 - lineSecond);
lineMinute -= 60*lineHour;
lineSecond -= 60*lineMinute;
sprintf( lineEndText, "%02d:%02d:%02d,%03d", lineHour, lineMinute, lineSecond, lineMs );
if(readline[0] & 0x80) {
jp = 1;
printf("Subtitles contain EUC-JP encoded text.\n");
}
if(jp && (!bom)) {
fwrite( utf8bom, 3, 1, o );
bom = 1;
}
if(jp) outputline = processLineJp( readline, header.textLength );
else outputline = processLine( readline );
fprintf( o, "%d\n%s --> %s\n%s\n\n", lineNumber, lineStartText, lineEndText, outputline );
lineNumber++;
free(outputline);
free(readline);
}
fclose(f);
fclose(o);
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
xorl %eax, %eax
movq %rax, 0x1d(%rsp)
movq %rax, 0x18(%rsp)
movq %rax, 0x4d(%rsp)
movq %rax, 0x48(%rsp)
cmpl $0x1, %edi
jg 0x13dc
movq (%r14), %rsi
leaq 0xc42(%rip), %rdi # 0x2019
jmp 0x16ca
movq 0x8(%r14), %rdi
leaq 0xc5a(%rip), %rsi # 0x2041
callq 0x10f0
movq 0x8(%r14), %r14
testq %rax, %rax
je 0x16b4
movq %rax, %rbx
movq %r14, %rdi
callq 0x1080
leaq 0x5(%rax), %rdi
callq 0x10c0
movq %rax, %r15
leaq 0xc43(%rip), %rsi # 0x205a
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1100
leaq 0xc36(%rip), %rsi # 0x2061
movq %r15, %rdi
callq 0x10f0
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x16c0
movq %r15, %rdi
callq 0x1030
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x10d0
movq %rbx, %rdi
callq 0x10b0
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10d0
movq %rbx, %rdi
callq 0x10b0
movl %r15d, %ecx
movq %rcx, 0x30(%rsp)
cmpq %rcx, %rax
je 0x169e
movl $0x1, %ebp
leaq 0x18(%rsp), %r14
leaq 0x48(%rsp), %r15
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movq %rbx, 0x28(%rsp)
movl $0x10, %esi
movl $0x1, %edx
leaq 0x38(%rsp), %rdi
movq %rbx, %rcx
callq 0x1060
movl 0x40(%rsp), %r13d
movq %r13, %rdi
callq 0x10c0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
movq %rbx, %rcx
callq 0x1060
movl 0x38(%rsp), %ecx
movq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movq %r14, %rdi
movl $0x88888889, %r14d # imm = 0x88888889
imulq %r14, %rax
shrq $0x25, %rax
movq %rcx, %rsi
movl $0x91a2b3c5, %edx # imm = 0x91A2B3C5
imulq %rdx, %rsi
shrq $0x2b, %rsi
shrl $0x6, %ecx
imulq $0x26d60dd, %rcx, %rdx # imm = 0x26D60DD
shrq $0x25, %rdx
movss 0xad8(%rip), %xmm1 # 0x2004
divss %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
subss %xmm1, %xmm0
movss 0xac5(%rip), %xmm1 # 0x2008
mulss %xmm1, %xmm0
cvttss2si %xmm0, %r9
imull $-0x3c, %edx, %ecx
addl %esi, %ecx
imull $-0x3c, %ecx, %r8d
addl %eax, %r8d
leaq 0xb05(%rip), %rbx # 0x2064
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1100
movl 0x3c(%rsp), %ecx
movq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
imulq %r14, %rax
shrq $0x25, %rax
movq %rcx, %rsi
movl $0x91a2b3c5, %edx # imm = 0x91A2B3C5
imulq %rdx, %rsi
shrq $0x2b, %rsi
shrl $0x6, %ecx
imulq $0x26d60dd, %rcx, %rdx # imm = 0x26D60DD
shrq $0x25, %rdx
divss 0xa5e(%rip), %xmm0 # 0x2004
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
subss %xmm1, %xmm0
mulss 0xa4f(%rip), %xmm0 # 0x2008
cvttss2si %xmm0, %r9
imull $-0x3c, %edx, %ecx
addl %esi, %ecx
imull $-0x3c, %ecx, %r8d
addl %eax, %r8d
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1100
cmpb $0x0, (%r12)
movl 0xc(%rsp), %edx
jns 0x15f3
leaq 0xaa1(%rip), %rdi # 0x208a
callq 0x1050
movl $0x1, %edx
testl %edx, %edx
sete %al
cmpl $0x0, 0x8(%rsp)
setne %cl
orb %al, %cl
movl %edx, 0xc(%rsp)
je 0x1620
testl %edx, %edx
movq 0x28(%rsp), %rbx
leaq 0x18(%rsp), %r14
jne 0x164d
movq %r12, %rdi
callq 0x12af
jmp 0x1658
movl $0x3, %esi
movl $0x1, %edx
leaq 0x2a77(%rip), %rdi # 0x40a8
movq 0x10(%rsp), %rcx
callq 0x1110
movl $0x1, 0x8(%rsp)
movq 0x28(%rsp), %rbx
leaq 0x18(%rsp), %r14
movq %r12, %rdi
movl %r13d, %esi
callq 0x131a
movq %rax, %r13
movq 0x10(%rsp), %rdi
leaq 0xa11(%rip), %rsi # 0x2078
movl %ebp, %edx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x10a0
incl %ebp
movq %r13, %rdi
callq 0x1030
movq %r12, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x10b0
cmpq 0x30(%rsp), %rax
jne 0x14ac
movq %rbx, %rdi
callq 0x1070
movq 0x10(%rsp), %rdi
callq 0x1070
xorl %eax, %eax
jmp 0x16d6
leaq 0x989(%rip), %rdi # 0x2044
movq %r14, %rsi
jmp 0x16ca
leaq 0x97d(%rip), %rdi # 0x2044
movq %r15, %rsi
xorl %eax, %eax
callq 0x1090
movl $0x1, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-zoe/subtitle-convert.c
|
getkey
|
int getkey() {
// Make reading from stdin non-blocking.
int flags = fcntl(STDIN_FILENO, F_GETFL);
fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK);
int ch = getchar();
// Turn off non-blocking I/O. On some systems, leaving stdin
// non-blocking will also leave stdout non-blocking, which
// can cause printing errors.
fcntl(STDIN_FILENO, F_SETFL, flags);
return ch;
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %edi, %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0x4100
movl %eax, %ebx
movl %eax, %edx
orl $0x800, %edx # imm = 0x800
xorl %edi, %edi
movl $0x4, %esi
xorl %eax, %eax
callq 0x4100
callq 0x4280
movl %eax, %r14d
xorl %edi, %edi
movl $0x4, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4100
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch2/eatyguy2.c
|
main
|
int main() {
start();
// Create a Lua state and load the module.
lua_State *L = luaL_newstate();
luaL_openlibs(L);
// Make our Lua-callable functions visible to Lua.
lua_register(L, "set_color", set_color);
lua_register(L, "set_pos", set_pos);
lua_register(L, "timestamp", timestamp);
// Load eatyguy2.lua and run the init() function.
luaL_dofile(L, "eatyguy2.lua");
lua_setglobal(L, "eatyguy");
lua_settop(L, 0);
lua_getglobal(L, "eatyguy");
lua_getfield(L, -1, "init"); // -1 means stack top.
lua_call(L, 0, 0); // 0, 0 = #args, #retvals
lua_getglobal(L, "eatyguy");
while (1) {
// Call eatyguy.loop().
lua_getfield(L, -1, "loop");
lua_call(L, 0, 0);
int c = getkey();
if (c == ESC_KEY || c == 'q' || c == 'Q') done();
}
return 0;
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x483e
callq 0x14d8d
movq %rax, %rbx
movq %rax, %rdi
callq 0x14f90
leaq -0x141(%rip), %rsi # 0x4896
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5584
leaq 0x1c694(%rip), %rsi # 0x2107c
movq %rbx, %rdi
callq 0x59c8
leaq -0xf7(%rip), %rsi # 0x4900
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5584
leaq 0x1c67e(%rip), %rsi # 0x21086
movq %rbx, %rdi
callq 0x59c8
leaq -0xac(%rip), %rsi # 0x496b
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5584
leaq 0x1c666(%rip), %rsi # 0x2108e
movq %rbx, %rdi
callq 0x59c8
leaq 0x1c661(%rip), %rsi # 0x21098
movq %rbx, %rdi
xorl %edx, %edx
callq 0x144e6
testl %eax, %eax
jne 0x4a5c
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5eab
leaq 0x1c642(%rip), %r14 # 0x210a5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x59c8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4c29
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5653
leaq 0x1c623(%rip), %rdx # 0x210ad
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x5771
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5e43
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5653
leaq 0x1d0aa(%rip), %r14 # 0x21b64
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x5771
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5e43
callq 0x47f1
cmpl $0x1b, %eax
je 0x4aef
cmpl $0x71, %eax
je 0x4aef
cmpl $0x51, %eax
jne 0x4aba
callq 0x4873
|
/workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch2/eatyguy2.c
|
main
|
int main(int argc, char **argv) {
if (pif_error(argc < 2, "No command specified"))
return usage(-1);
if (pif_error(argc < 3, "No DB path specified"))
return usage(-1);
char *cmd = argv[1];
char *keyData[JFT_KEY_LIMIT];
JFDB *db;
JFT_Stem prefix = (JFT_Stem) {.data = (uint8_t *)keyData};
JFT_Symbol *stop = NULL;
JFT_Offset offset;
switch (cmd[0]) {
case 'm':
case 'n':
case 'k':
case 'f':
case 'l':
case 'c':
db = JFDB_open(argv[2], 0);
if (JFDB_pif_error(db, "Failed to open"))
return -1;
switch (cmd[0]) {
case 'm':
print_meta(db);
break;
case 'n':
offset = argc > 3 ? atoi(argv[3]) : db->tip.cp.offset;
offset = MAX(offset, sizeof(JFDB_Header));
print_info(db, &prefix, db->kmap.map + offset, &null);
break;
case 'k':
if (!prefix_opts(&prefix, &stop, argc - 2, argv + 2))
print_keys(db, &prefix, stop);
break;
case 'f':
if (!prefix_opts(&prefix, &stop, argc - 2, argv + 2))
print_find(db, &prefix, stop);
break;
case 'l':
load_input(db, stdin);
break;
case 'c':
JFDB_crush(db);
break;
}
if (JFDB_close(db))
return -1;
break;
case 'w':
if (pif_error(JFDB_wipe(argv[2]), "Failed to wipe"))
return -1;
break;
default:
usage(1);
break;
}
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2028, %rsp # imm = 0x2028
cmpl $0x1, %edi
jle 0x1621
movl %edi, %ebp
cmpl $0x2, %edi
je 0x1628
movq %rsi, %r14
movq 0x8(%rsi), %r15
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movw $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq %rax, (%rsp)
movzbl (%r15), %eax
addl $-0x63, %eax
cmpl $0x14, %eax
ja 0x1688
movl $0xf09, %ecx # imm = 0xF09
btl %eax, %ecx
jae 0x150f
movq 0x10(%r14), %rdi
xorl %esi, %esi
callq 0x2845
movq %rax, %rbx
testq %rax, %rax
je 0x15dd
cmpl $0x0, 0x88(%rbx)
jne 0x15dd
movzbl (%r15), %eax
addl $-0x63, %eax
cmpl $0xb, %eax
ja 0x1663
leaq 0x10(%r14), %rcx
leaq 0x5b17(%rip), %rdx # 0x7010
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x4053
jmp 0x1663
cmpl $0x14, %eax
jne 0x1688
movq 0x10(%r14), %rdi
callq 0x27c0
testl %eax, %eax
je 0x1678
callq 0x1288
jmp 0x162d
addl $-0x2, %ebp
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
movl %ebp, %edx
callq 0x22f5
testl %eax, %eax
jne 0x1663
movq (%rsp), %rdx
leaq 0x110f(%rip), %rcx # 0x2667
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x412a
jmp 0x1663
cmpl $0x4, %ebp
jb 0x1634
movq 0x18(%r14), %rdi
callq 0x11f0
cltq
jmp 0x163b
addl $-0x2, %ebp
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
movl %ebp, %edx
callq 0x22f5
testl %eax, %eax
jne 0x1663
movq (%rsp), %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x24bf
jmp 0x1663
movq 0x8a08(%rip), %rax # 0x9fc8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2500
jmp 0x1663
movq %rbx, %rdi
callq 0x168f
jmp 0x1663
leaq 0x8(%rbx), %rax
testq %rbx, %rbx
movq 0x8a0d(%rip), %rcx # 0x9ff8
movq (%rcx), %rdi
leaq 0x5d01(%rip), %rcx # 0x72f6
cmovneq %rax, %rcx
leaq 0x5cee(%rip), %rsi # 0x72ee
leaq 0x5bf3(%rip), %rdx # 0x71fa
xorl %eax, %eax
callq 0x1160
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x0, 0x88(%rbx)
jne 0x167a
jmp 0x14de
callq 0x1250
jmp 0x162d
callq 0x12d1
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x167a
movq 0x128(%rbx), %rax
cmpq $0x71, %rax
movl $0x70, %edx
cmovaeq %rax, %rdx
addq 0x98(%rbx), %rdx
leaq 0x8b82(%rip), %rcx # 0xa1d8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1810
movq %rbx, %rdi
callq 0x33a0
movq %rax, %rcx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rcx, %rcx
jne 0x167a
xorl %eax, %eax
addq $0x2028, %rsp # imm = 0x2028
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x12ad
jmp 0x1678
|
/workspace/github_c_makefile_star2_O3/jflatow[P]jfdb/src/jfdb.c
|
print_meta
|
static void print_meta(JFDB *db) {
JFDB_CheckPoint *cp = &db->tip.cp;
printf("-----\n");
printf("magic: %x:%x\n", db->tip.magic, db->tip.version);
printf("level: %"PRIu64" / %llu\n", cp->levels, 1LLU << db->tip.level);
printf("-----\n");
printf("gaps:\n");
for (int i = 0; i < JFDB_NUM_GAPS; i++)
printf(" %8u @ %-8u\n", cp->gaps[i].size, cp->gaps[i].block);
printf("keys: %12zu / %-12"PRIu64"\n", db->kmap.size, cp->lengthKeys);
printf("vals: %12zu / %-12"PRIu64"\n", db->vmap.size, cp->lengthVals);
printf("-----\n");
printf("roots:\n");
JFT *trie;
for (JFT_Offset pos = cp->offset; pos; pos = JFT_parent_offset(trie)) {
trie = JFDB_get_trie(db, pos);
printf(" %12"PRIu64" = ", pos);
print_bits((JFT_Head *)trie, 1);
printf("\n");
}
printf("-----\n");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5f3a(%rip), %r14 # 0x75de
movq %r14, %rdi
callq 0x1080
movl 0xc0(%rbx), %esi
movl 0xc4(%rbx), %edx
leaq 0x5c48(%rip), %rdi # 0x7307
xorl %eax, %eax
callq 0x10f0
movq 0x120(%rbx), %rsi
movb 0xc8(%rbx), %cl
movl $0x1, %edx
shlq %cl, %rdx
leaq 0x5c33(%rip), %rdi # 0x7315
xorl %eax, %eax
callq 0x10f0
movq %r14, %rdi
callq 0x1080
leaq 0x5ed9(%rip), %rdi # 0x75d1
callq 0x1080
movl $0x1a, %r15d
leaq 0x5c1e(%rip), %r14 # 0x7328
movl (%rbx,%r15,8), %edx
movl 0x4(%rbx,%r15,8), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10f0
incq %r15
cmpq $0x22, %r15
jne 0x170a
movq 0xa0(%rbx), %rsi
movq 0x110(%rbx), %rdx
leaq 0x5bfa(%rip), %rdi # 0x7335
xorl %eax, %eax
callq 0x10f0
movq 0xb8(%rbx), %rsi
movq 0x118(%rbx), %rdx
leaq 0x5bf4(%rip), %rdi # 0x734b
xorl %eax, %eax
callq 0x10f0
leaq 0x5e79(%rip), %rdi # 0x75de
callq 0x1080
leaq 0x5e66(%rip), %rdi # 0x75d7
callq 0x1080
movq 0x128(%rbx), %r12
testq %r12, %r12
je 0x17f6
leaq 0x5be7(%rip), %r13 # 0x7370
leaq 0x5dd7(%rip), %rbp # 0x7567
movabsq $0xffffffffff, %r14 # imm = 0xFFFFFFFFFF
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3bff
movq %rax, %r15
leaq 0x5bb2(%rip), %rdi # 0x7361
movq %r12, %rsi
xorl %eax, %eax
callq 0x10f0
movl $0x3f, %r12d
testb $0x7, %r12b
movq %rbp, %rdi
cmoveq %r13, %rdi
movq (%r15), %rax
xorl %esi, %esi
btq %r12, %rax
setb %sil
xorl %eax, %eax
callq 0x10f0
addq $-0x1, %r12
jb 0x17bf
movl $0xa, %edi
callq 0x1040
movq (%r15), %r12
andq %r14, %r12
jne 0x179a
leaq 0x5de1(%rip), %rdi # 0x75de
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
|
/workspace/github_c_makefile_star2_O3/jflatow[P]jfdb/src/jfdb.c
|
print_info
|
static void print_info(JFDB *db, JFT_Stem *prefix, JFT *node, JFT_Symbol *stop) {
JFT_Stem key = JFT_key(node, db->keyData), val = (JFT_Stem) {};
printf("-----\n");
printf("@ %ld\n", node - db->kmap.map);
print_stem("> ", *prefix);
print_stem("< ", key);
print_node(node);
if (JFT_node_type(node) == Leaf)
if (key.pre == JFT_SYMBOL_PRIMARY)
if (JFDB_get_value(db, node, &val))
print_stem("= ", val);
JFT_Cursor cursor = JFT_cursor(node);
for (JFT_Keys keys = JFT_keys(&cursor, &key, Forward); JFT_keys_next_until(&keys, stop); )
print_stem(JFT_cursor_at_terminal(&cursor) ? "[val] " : "[sub] ", *keys.stem);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x68(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movabsq $0xffffffffff, %r15 # imm = 0xFFFFFFFFFF
movq $0x0, 0x8(%rsp)
movw $0x0, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
leaq 0xd98(%rdi), %r13
movq %r13, 0x18(%rsp)
movq (%rdx), %rax
movq %rax, %rcx
shrq $0x3e, %rcx
movq %rdx, (%rsp)
je 0x1903
movq %r14, 0x88(%rsp)
movabsq $0x4000000000000000, %rbp # imm = 0x4000000000000000
xorl %r14d, %r14d
movabsq $0x2000000000000000, %rcx # imm = 0x2000000000000000
testq %rcx, %rax
jne 0x1898
leaq 0x8(%rbx), %rsi
xorl %r12d, %r12d
jmp 0x18a8
movzbl 0x8(%rbx), %r12d
orq $-0x100, %r12
leaq 0x9(%rbx), %rsi
shrq $0x30, %rax
andl $0xfff, %eax # imm = 0xFFF
cmpq $0x1, %r12
movl %eax, %ecx
adcw $-0x1, %cx
addl %eax, %r14d
movzwl %cx, %edx
subq %rdx, %r13
movq %r13, %rdi
callq 0x1170
movq (%rbx), %rax
andq %r15, %rax
movq %rbx, %rcx
subq %rax, %rcx
negq %rax
movq (%rbx,%rax), %rax
movq %rcx, %rbx
cmpq %rbp, %rax
jae 0x1880
movq %r12, 0x8(%rsp)
movw %r14w, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq (%rsp), %rbx
movq 0x88(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x90(%rsp)
movq $0x0, 0xa0(%rsp)
leaq 0x5cbd(%rip), %rdi # 0x75de
callq 0x1080
movq 0x60(%rsp), %rax
subq 0x98(%rax), %rbx
leaq 0x5a3c(%rip), %rdi # 0x7375
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10f0
movq 0x10(%r14), %rax
movq %rax, 0x30(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x5f31(%rip), %rdi # 0x788d
leaq 0x5a19(%rip), %rsi # 0x737c
xorl %eax, %eax
callq 0x10f0
movq 0x20(%rsp), %rbx
leaq 0x5(%rbx), %rax
cmpq $0x5, %rax
ja 0x19b6
leaq 0x56c0(%rip), %rcx # 0x7040
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5a19(%rip), %rsi # 0x73a9
jmp 0x19bb
leaq 0x5a08(%rip), %rsi # 0x73a1
jmp 0x19bb
leaq 0x5a0f(%rip), %rsi # 0x73b1
jmp 0x19bb
leaq 0x59fa(%rip), %rsi # 0x73a5
jmp 0x19bb
leaq 0x59e9(%rip), %rsi # 0x739d
jmp 0x19bb
leaq 0x20(%rsp), %rsi
leaq 0x59ce(%rip), %rdi # 0x7390
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10f0
cmpq 0x20(%rsp), %rbx
sbbq %rbx, %rbx
movzwl 0x28(%rsp), %r14d
addq %rbx, %r14
je 0x1a2c
movq 0x30(%rsp), %rbx
xorl %r12d, %r12d
xorl %ebp, %ebp
movzbl (%rbx,%rbp), %esi
leal -0x7f(%rsi), %eax
cmpb $-0x60, %al
ja 0x1a07
leaq 0x1(%r12), %r13
testb $0x1, %r12b
jne 0x1a13
leaq 0x59c0(%rip), %rdi # 0x73c5
jmp 0x1a1a
movl %esi, %edi
callq 0x1040
movq %r12, %r13
jmp 0x1a21
leaq 0x599f(%rip), %rdi # 0x73b9
xorl %eax, %eax
callq 0x10f0
incq %rbp
movq %r13, %r12
cmpq %rbp, %r14
jne 0x19e8
movl $0xa, %edi
callq 0x1040
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movups 0x8(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x5e3c(%rip), %rdi # 0x788d
leaq 0x5927(%rip), %rsi # 0x737f
xorl %eax, %eax
callq 0x10f0
movq 0x20(%rsp), %rbx
leaq 0x5(%rbx), %rax
cmpq $0x5, %rax
ja 0x1aab
leaq 0x55e3(%rip), %rcx # 0x7058
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5924(%rip), %rsi # 0x73a9
jmp 0x1ab0
leaq 0x5913(%rip), %rsi # 0x73a1
jmp 0x1ab0
leaq 0x591a(%rip), %rsi # 0x73b1
jmp 0x1ab0
leaq 0x5905(%rip), %rsi # 0x73a5
jmp 0x1ab0
leaq 0x58f4(%rip), %rsi # 0x739d
jmp 0x1ab0
leaq 0x20(%rsp), %rsi
leaq 0x58d9(%rip), %rdi # 0x7390
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10f0
cmpq 0x20(%rsp), %rbx
sbbq %rbx, %rbx
movzwl 0x28(%rsp), %r14d
addq %rbx, %r14
je 0x1b21
movq 0x30(%rsp), %rbx
xorl %r12d, %r12d
xorl %ebp, %ebp
movzbl (%rbx,%rbp), %esi
leal -0x7f(%rsi), %eax
cmpb $-0x60, %al
ja 0x1afc
leaq 0x1(%r12), %r13
testb $0x1, %r12b
jne 0x1b08
leaq 0x58cb(%rip), %rdi # 0x73c5
jmp 0x1b0f
movl %esi, %edi
callq 0x1040
movq %r12, %r13
jmp 0x1b16
leaq 0x58aa(%rip), %rdi # 0x73b9
xorl %eax, %eax
callq 0x10f0
incq %rbp
movq %r13, %r12
cmpq %rbp, %r14
jne 0x1add
movl $0xa, %edi
callq 0x1040
movq (%rsp), %rbx
movq (%rbx), %r12
leaq 0x8(%rbx), %r14
movabsq $0x2000000000000000, %rax # imm = 0x2000000000000000
testq %rax, %r12
jne 0x1b4d
xorl %r13d, %r13d
movq %r14, %rbp
jmp 0x1b5d
movzbl 0x8(%rbx), %r13d
orq $-0x100, %r13
leaq 0x9(%rbx), %rbp
shrq $0x30, %r12
andl $0xfff, %r12d # imm = 0xFFF
leaq 0x5a6f(%rip), %rdi # 0x75de
callq 0x1080
movq (%rbx), %rax
movq %rax, %rdx
movq %rax, %rcx
movq %rax, %rdi
andq %rax, %r15
shrq $0x3e, %rax
leaq 0x5632(%rip), %r8 # 0x71c0
movslq (%r8,%rax,4), %rsi
addq %r8, %rsi
shrq $0x3d, %rdx
andl $0x1, %edx
shrq $0x3c, %rcx
andl $0x1, %ecx
shrq $0x28, %rdi
movzbl %dil, %r9d
subq $0x8, %rsp
leaq 0x581b(%rip), %rdi # 0x73d1
movl %r12d, %r8d
xorl %eax, %eax
pushq %r15
callq 0x10f0
addq $0x10, %rsp
movq %r13, 0x20(%rsp)
movw %r12w, 0x28(%rsp)
movq %rbp, 0x30(%rsp)
leaq 0x5(%r13), %rax
cmpq $0x5, %rax
ja 0x1c1d
leaq 0x5489(%rip), %rcx # 0x7070
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x57b2(%rip), %rsi # 0x73a9
jmp 0x1c22
leaq 0x57a1(%rip), %rsi # 0x73a1
jmp 0x1c22
leaq 0x57a8(%rip), %rsi # 0x73b1
jmp 0x1c22
leaq 0x5793(%rip), %rsi # 0x73a5
jmp 0x1c22
leaq 0x5782(%rip), %rsi # 0x739d
jmp 0x1c22
leaq 0x20(%rsp), %rsi
leaq 0x5767(%rip), %rdi # 0x7390
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x10f0
cmpq 0x20(%rsp), %r13
sbbq %r13, %r13
movq 0x30(%rsp), %rbp
movzwl 0x28(%rsp), %r12d
movzwl %r12w, %r15d
addq %r13, %r15
je 0x1c99
xorl %r12d, %r12d
xorl %ebx, %ebx
movzbl (%rbp,%rbx), %esi
leal -0x7f(%rsi), %eax
cmpb $-0x60, %al
ja 0x1c74
leaq 0x1(%r12), %r13
testb $0x1, %r12b
jne 0x1c80
leaq 0x5753(%rip), %rdi # 0x73c5
jmp 0x1c87
movl %esi, %edi
callq 0x1040
movq %r12, %r13
jmp 0x1c8e
leaq 0x5732(%rip), %rdi # 0x73b9
xorl %eax, %eax
callq 0x10f0
incq %rbx
movq %r13, %r12
cmpq %rbx, %r15
jne 0x1c54
movl $0xa, %edi
callq 0x1040
leaq 0x5934(%rip), %rdi # 0x75de
callq 0x1080
movq (%rsp), %rax
movq (%rax), %rbx
movq %rbx, %rax
shrq $0x3e, %rax
leaq 0x53c4(%rip), %rcx # 0x7088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
movl 0x20(%rax), %r8d
movl 0x24(%rax), %r9d
movl 0x28(%rax), %r10d
movzwl 0x2c(%rax), %r11d
leaq 0x579f(%rip), %rdi # 0x7494
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x10f0
addq $0x10, %rsp
jmp 0x1ebd
movq %rbx, %rax
shrq $0x28, %rax
movzbl %al, %eax
shrq $0x30, %rbx
andl $0xfff, %ebx # imm = 0xFFF
addq %rbx, %r14
shll $0x4, %eax
leaq 0x53e6(%rip), %rcx # 0x7110
movq (%rax,%rcx), %r15
movq 0x8(%rax,%rcx), %rbx
leaq 0x58b5(%rip), %rdi # 0x75ef
callq 0x1080
incq %rbx
leaq 0x567c(%rip), %r12 # 0x73c5
leaq 0x57f4(%rip), %r13 # 0x7544
movq (%r14), %rbp
movl $0x20, %edi
callq 0x1040
movzbl %r15b, %esi
leal -0x7f(%r15), %eax
cmpb $-0x60, %al
ja 0x1d75
movq %r12, %rdi
xorl %eax, %eax
callq 0x10f0
jmp 0x1d7c
movl %esi, %edi
callq 0x1040
movq %r13, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10f0
incq %r15
addq $0x8, %r14
cmpq %r15, %rbx
jne 0x1d50
jmp 0x1ebd
movq %rbx, %r12
shrq $0x28, %r12
movl $0xff, %eax
andl %eax, %r12d
shrq $0x30, %rbx
andl $0xfff, %ebx # imm = 0xFFF
addq %rbx, %r14
cmpl %eax, %r12d
jne 0x1dc2
movl (%r14), %r12d
addq $0x4, %r14
leaq 0x5781(%rip), %rdi # 0x754a
movl %r12d, %esi
xorl %eax, %eax
callq 0x10f0
leaq 0x5780(%rip), %rdi # 0x755a
xorl %eax, %eax
callq 0x10f0
testl %r12d, %r12d
je 0x1e29
movl $0x2710, %ebx # imm = 0x2710
cmpl %ebx, %r12d
cmovbl %r12d, %ebx
leaq 0x576d(%rip), %r15 # 0x7566
xorl %r13d, %r13d
movq (%r14,%r13,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10f0
incq %r13
cmpq %r13, %rbx
jne 0x1dfc
cmpl $0x2710, %r12d # imm = 0x2710
jbe 0x1e29
leaq 0x5749(%rip), %rdi # 0x756b
xorl %eax, %eax
callq 0x10f0
movl $0xa, %edi
callq 0x1040
jmp 0x1ebd
movq %rbx, %r15
shrq $0x28, %r15
leaq 0x579e(%rip), %rdi # 0x75e4
callq 0x1080
testb %r15b, %r15b
je 0x1ebd
shrq $0x30, %rbx
andl $0xfff, %ebx # imm = 0xFFF
addq %rbx, %r14
movzbl %r15b, %ebx
leaq (%r14,%rbx), %r12
negq %rbx
xorl %r13d, %r13d
movzbl (%r14,%r13), %r15d
movq (%r12,%r13,8), %rbp
movl $0x20, %edi
callq 0x1040
leal -0x7f(%r15), %eax
cmpb $-0x60, %al
ja 0x1e99
leaq 0x5538(%rip), %rdi # 0x73c5
movl %r15d, %esi
xorl %eax, %eax
callq 0x10f0
jmp 0x1ea1
movl %r15d, %edi
callq 0x1040
leaq 0x569c(%rip), %rdi # 0x7544
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10f0
incq %r13
movq %rbx, %rax
addq %r13, %rax
jne 0x1e6b
leaq 0x571a(%rip), %rdi # 0x75de
callq 0x1080
movq (%rsp), %rbx
movq (%rbx), %rax
shrq $0x3e, %rax
cmpl $0x3, %eax
jb 0x2009
cmpq $-0x5, 0x8(%rsp)
jne 0x2009
leaq 0x90(%rsp), %rdx
movq 0x60(%rsp), %rdi
movq %rbx, %rsi
callq 0x4070
testq %rax, %rax
je 0x2009
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
movaps 0x90(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x5965(%rip), %rdi # 0x788d
leaq 0x543e(%rip), %rsi # 0x736d
xorl %eax, %eax
callq 0x10f0
movq 0x20(%rsp), %rbx
leaq 0x5(%rbx), %rax
cmpq $0x5, %rax
ja 0x1f82
leaq 0x514c(%rip), %rcx # 0x7098
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x544d(%rip), %rsi # 0x73a9
jmp 0x1f87
leaq 0x543c(%rip), %rsi # 0x73a1
jmp 0x1f87
leaq 0x5443(%rip), %rsi # 0x73b1
jmp 0x1f87
leaq 0x542e(%rip), %rsi # 0x73a5
jmp 0x1f87
leaq 0x541d(%rip), %rsi # 0x739d
jmp 0x1f87
leaq 0x20(%rsp), %rsi
leaq 0x5402(%rip), %rdi # 0x7390
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10f0
cmpq 0x20(%rsp), %rbx
sbbq %rbx, %rbx
movzwl 0x28(%rsp), %r14d
addq %rbx, %r14
je 0x1ffb
movq 0x30(%rsp), %rbx
leaq 0x5403(%rip), %r12 # 0x73b9
xorl %ebp, %ebp
xorl %r13d, %r13d
movzbl (%rbx,%r13), %esi
leal -0x7f(%rsi), %eax
cmpb $-0x60, %al
ja 0x1fda
leaq 0x1(%rbp), %r15
testb $0x1, %bpl
jne 0x1fe6
leaq 0x53ed(%rip), %rdi # 0x73c5
jmp 0x1fe9
movl %esi, %edi
callq 0x1040
movq %rbp, %r15
jmp 0x1ff0
movq %r12, %rdi
xorl %eax, %eax
callq 0x10f0
incq %r13
movq %r15, %rbp
cmpq %r13, %r14
jne 0x1fbb
movl $0xa, %edi
callq 0x1040
movq (%rsp), %rbx
movabsq $-0x4000000000000001, %r12 # imm = 0xBFFFFFFFFFFFFFFF
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movq %rbx, (%r15)
movq %r15, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x4500
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x4a2f
xorl %r13d, %r13d
movzwl 0x8(%r14), %ebp
leaq 0x532d(%rip), %r14 # 0x7389
movq $0x0, (%rsp)
movq 0x68(%rsp), %rbx
cmpq $0x0, (%rsp)
je 0x20f4
movq %r15, %rdi
movl $0x1, %esi
callq 0x49ad
movzwl 0x10(%rsp), %ecx
cmpq $-0x2, %rax
jb 0x20b3
subw $0x1, %cx
movw %cx, 0x10(%rsp)
jb 0x22e3
movq %r15, %rdi
movl $0x1, %esi
callq 0x45bb
cmpq $-0x4, %rax
jbe 0x2074
jmp 0x22e3
cmpw %bp, %cx
jbe 0x22e3
movq 0x50(%rsp), %rax
decl %ecx
je 0x20d9
cmpq $0x1, 0x8(%rsp)
movq 0x18(%rsp), %rdx
adcq $-0x1, %rdx
movb %al, (%rdx,%rcx)
jmp 0x20f4
cmpq $0x100, %rax # imm = 0x100
movl $0x0, %ecx
cmovaeq %rax, %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movb %al, (%rcx)
incq (%rsp)
testq %rbx, %rbx
je 0x210b
movq 0x50(%rsp), %rax
cmpq (%rbx), %rax
je 0x21a2
movq 0x28(%rsp), %rax
cmpq %r12, (%rax)
jbe 0x2128
movzwl 0x38(%rsp), %eax
decq %rax
cmpq %rax, 0x48(%rsp)
je 0x21af
movq %r15, %rdi
movl $0x1, %esi
callq 0x4617
cmpq $-0x2, %rax
jae 0x2186
movzwl 0x10(%rsp), %ecx
leal 0x1(%rcx), %eax
movw %ax, 0x10(%rsp)
movq 0x50(%rsp), %rax
testq %rcx, %rcx
je 0x2166
cmpq $0x1, 0x8(%rsp)
movq 0x18(%rsp), %rdx
adcq $-0x1, %rdx
movb %al, (%rdx,%rcx)
jmp 0x20f8
cmpq $0x100, %rax # imm = 0x100
movl $0x0, %ecx
cmovaeq %rax, %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movb %al, (%rcx)
jmp 0x20f8
movq %r15, %rdi
movl $0x1, %esi
callq 0x45bb
cmpq $-0x4, %rax
jbe 0x2069
jmp 0x22e3
movq 0x28(%rsp), %rax
movq %r14, %rsi
cmpq %r12, (%rax)
jbe 0x21c7
movzwl 0x38(%rsp), %eax
decq %rax
cmpq %rax, 0x48(%rsp)
leaq 0x51bf(%rip), %rsi # 0x7382
cmovneq %r14, %rsi
movw %bp, 0x60(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x80(%rsp)
movups 0x8(%rsp), %xmm0
movaps %xmm0, 0x70(%rsp)
leaq 0x56a3(%rip), %rdi # 0x788d
xorl %eax, %eax
callq 0x10f0
movq 0x70(%rsp), %rax
leaq 0x5(%rax), %rcx
cmpq $0x5, %rcx
ja 0x223b
leaq 0x4ea9(%rip), %rdx # 0x70b0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
leaq 0x5188(%rip), %rsi # 0x739d
jmpq *%rcx
leaq 0x518b(%rip), %rsi # 0x73a9
jmp 0x2240
leaq 0x517e(%rip), %rsi # 0x73a5
jmp 0x2240
leaq 0x5181(%rip), %rsi # 0x73b1
jmp 0x2240
leaq 0x5168(%rip), %rsi # 0x73a1
jmp 0x2240
leaq 0x70(%rsp), %rsi
leaq 0x5149(%rip), %rdi # 0x7390
xorl %eax, %eax
callq 0x10f0
cmpq 0x70(%rsp), %r13
movl $0x0, %eax
sbbq %rax, %rax
movzwl 0x78(%rsp), %r13d
addq %rax, %r13
je 0x22b6
movq 0x80(%rsp), %rbx
xorl %r14d, %r14d
xorl %ebp, %ebp
movzbl (%rbx,%rbp), %esi
leal -0x7f(%rsi), %eax
cmpb $-0x60, %al
ja 0x2291
leaq 0x1(%r14), %r12
testb $0x1, %r14b
jne 0x229d
leaq 0x5136(%rip), %rdi # 0x73c5
jmp 0x22a4
movl %esi, %edi
callq 0x1040
movq %r14, %r12
jmp 0x22ab
leaq 0x5115(%rip), %rdi # 0x73b9
xorl %eax, %eax
callq 0x10f0
incq %rbp
movq %r12, %r14
cmpq %rbp, %r13
jne 0x2273
movl $0xa, %edi
callq 0x1040
movq 0x68(%rsp), %rbx
movabsq $-0x4000000000000001, %r12 # imm = 0xBFFFFFFFFFFFFFFF
xorl %r13d, %r13d
movzwl 0x60(%rsp), %ebp
leaq 0x50ab(%rip), %r14 # 0x7389
jmp 0x2069
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/jflatow[P]jfdb/src/jfdb.c
|
prefix_opts
|
static int prefix_opts(JFT_Stem *prefix, JFT_Symbol **stop, int argc, char **argv) {
extern char *optarg;
extern int optind, optopt;
int opt, ptr, err = 0, omit = 1;
static struct option options[] = {
{"null", no_argument, NULL, 'n'},
{"stop", no_argument, NULL, 's'},
{"primary", no_argument, NULL, 'p'},
{"indices", no_argument, NULL, 'i'},
{}
};
// default
prefix->pre = JFT_SYMBOL_PRIMARY;
prefix->size = 1;
while ((opt = getopt_long(argc, argv, "hnspi", options, &ptr)) != -1) {
switch (opt) {
case 'h':
return usage(0);
case 'n':
omit = 0;
break;
case 's':
*stop = &null;
break;
case 'p':
prefix->pre = JFT_SYMBOL_PRIMARY;
prefix->size = 1;
break;
case 'i':
prefix->pre = JFT_SYMBOL_INDICES;
prefix->size = 1;
break;
case ':':
pwarn("%s: option requires an argument -- %c", argv[0], optopt);
err++;
break;
case '?':
pwarn("%s: illegal option -- %c", argv[0], optopt);
err++;
break;
}
}
read_prefix(prefix, omit, argc - optind, argv + optind);
return err;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movl %edx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movq $-0x5, (%rdi)
movw $0x1, 0x8(%rdi)
movl $0x1, 0xc(%rsp)
xorl %ebp, %ebp
leaq 0x7e00(%rip), %rbx # 0xa130
leaq 0x44(%rsp), %r12
leaq 0x4d8c(%rip), %r13 # 0x70c8
movl 0x8(%rsp), %edi
movq %r15, %rsi
leaq 0x5240(%rip), %rdx # 0x758a
movq %rbx, %rcx
movq %r12, %r8
callq 0x10e0
cmpl $0x67, %eax
jle 0x239d
addl $-0x68, %eax
cmpl $0xb, %eax
ja 0x233c
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq $-0x4, (%r14)
movw $0x1, 0x8(%r14)
jmp 0x233c
movq 0x10(%rsp), %rax
leaq 0x7e50(%rip), %rcx # 0xa1d8
movq %rcx, (%rax)
jmp 0x233c
movq $-0x5, (%r14)
movw $0x1, 0x8(%r14)
jmp 0x233c
cmpl $-0x1, %eax
je 0x23f9
cmpl $0x3a, %eax
je 0x23c3
cmpl $0x3f, %eax
jne 0x233c
movq %r15, %rdi
callq 0x1309
jmp 0x23cb
movl $0x0, 0xc(%rsp)
jmp 0x233c
movq %r15, %rdi
callq 0x1336
incl %ebp
jmp 0x233c
movq 0x7be7(%rip), %rax # 0x9fc0
movq (%rax), %rcx
leaq 0x4e40(%rip), %rdi # 0x7223
movl $0xca, %esi
movl $0x1, %edx
callq 0x1200
xorl %eax, %eax
jmp 0x24b0
movl %ebp, 0x1c(%rsp)
movq 0x7bcc(%rip), %rax # 0x9fd0
movslq (%rax), %rcx
movl 0x8(%rsp), %eax
subl %ecx, %eax
movq %rcx, 0x28(%rsp)
movq %r14, 0x20(%rsp)
jle 0x2483
leaq (%r15,%rcx,8), %rcx
movq %rcx, 0x38(%rsp)
movl %eax, %eax
movq %rax, 0x30(%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
movq 0x20(%rsp), %r15
movq 0x38(%rsp), %rax
movq (%rax,%rbp,8), %rbx
movq %rbx, %rdi
callq 0x10c0
movq %rax, 0x10(%rsp)
movzwl %r13w, %r14d
movq 0x10(%r15), %rdi
addq %r14, %rdi
movzwl %ax, %r12d
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1170
addq 0x10(%r15), %r12
movb $0x0, (%r14,%r12)
movq 0x10(%rsp), %rax
addl %eax, %r13d
incl %r13d
incq %rbp
cmpq %rbp, 0x30(%rsp)
jne 0x2433
jmp 0x2486
xorl %r13d, %r13d
movq 0x28(%rsp), %rax
cmpl %eax, 0x8(%rsp)
setne %al
cmpl $0x0, 0xc(%rsp)
setne %cl
andb %al, %cl
movzbl %cl, %eax
subl %eax, %r13d
movq 0x20(%rsp), %rax
addw %r13w, 0x8(%rax)
movl 0x1c(%rsp), %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/jflatow[P]jfdb/src/jfdb.c
|
load_input
|
static void load_input(JFDB *db, FILE *input) {
int c, s = 0, n = 2;
JFT_Stem *stems = malloc(n * sizeof(JFT_Stem));
JFT_Boolean escaped = False;
char *buf = malloc(1 << 20); // NB: static buffer
size_t bufSize = 0;
stems[0] = (JFT_Stem) {
.size = 0,
.data = (uint8_t *)buf
};
while ((c = getc(input)) != EOF) {
if (escaped) {
// copy byte no matter what
buf[bufSize++] = c;
stems[s].size++;
escaped = False;
} else if (c == '\\') {
// escape the next byte
escaped = True;
} else if (c == '\t') {
// close out current stem, start next one
if (++s >= n)
stems = realloc(stems, (n *= 2) * sizeof(JFT_Stem));
stems[s] = (JFT_Stem) {
.size = 0,
.data = (uint8_t *)&buf[bufSize]
};
} else if (c == '\n') {
// close out current stem, write db, reset
if (s)
JFDB_store(db, &stems[0], &stems[1], &stems[2], s > 1 ? s - 1 : 0, 0);
else
JFDB_annul(db, &stems[0], 0);
bufSize = s = 0;
stems[s].size = 0;
} else {
// copy byte
buf[bufSize++] = c;
stems[s].size++;
}
}
free(stems);
free(buf);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movl $0x30, %edi
callq 0x1180
movq %rax, %r12
movl $0x100000, %edi # imm = 0x100000
callq 0x1180
movq %rax, %r15
movq $0x0, (%r12)
movw $0x0, 0x8(%r12)
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x1230
cmpl $-0x1, %eax
je 0x2649
movl $0x2, 0xc(%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
xorl %r14d, %r14d
testl %ebp, %ebp
jne 0x25c6
cmpl $0x5c, %eax
je 0x2621
cmpl $0xa, %eax
je 0x25ef
cmpl $0x9, %eax
jne 0x25c6
incl %r13d
movl 0xc(%rsp), %eax
cmpl %eax, %r13d
jl 0x25a4
addl %eax, %eax
movl %eax, 0xc(%rsp)
cltq
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
movq %r12, %rdi
callq 0x1190
movq %rax, %r12
movslq %r13d, %rax
leaq (%rax,%rax,2), %rax
leaq (%r15,%r14), %rcx
movq $0x0, (%r12,%rax,8)
movw $0x0, 0x8(%r12,%rax,8)
movq %rcx, 0x10(%r12,%rax,8)
jmp 0x25da
movb %al, (%r15,%r14)
incq %r14
movslq %r13d, %rax
leaq (%rax,%rax,2), %rax
incw 0x8(%r12,%rax,8)
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x1230
cmpl $-0x1, %eax
jne 0x2566
jmp 0x2649
testl %r13d, %r13d
je 0x2628
leaq 0x18(%r12), %rdx
leaq 0x30(%r12), %rcx
leal -0x1(%r13), %r8d
cmpl $0x2, %r13d
movl $0x0, %eax
cmovll %eax, %r8d
movq 0x10(%rsp), %rdi
movq %r12, %rsi
xorl %r9d, %r9d
callq 0x3ed6
jmp 0x2637
movl $0x1, %ebp
jmp 0x25dc
movq 0x10(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3e71
movw $0x0, 0x8(%r12)
xorl %r14d, %r14d
xorl %ebp, %ebp
xorl %r13d, %r13d
jmp 0x25dc
movq %r12, %rdi
callq 0x1030
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
|
/workspace/github_c_makefile_star2_O3/jflatow[P]jfdb/src/jfdb.c
|
main
|
int main (){
uint32_t i;
obmap *test_map, *map_copy;
obtest *a, *b, *c, *d, *e, *f, *g, *h;
obtest *test_array[ARRAY_SIZE];
obtest *test;
test_map = obmap_new();
a = obtest_new(1);
b = obtest_new(2);
c = obtest_new(3);
d = obtest_new(103923);
e = obtest_new(1+MAP_CAPACITIES[0]); /* ensures hash collision with a */
f = obtest_new(1+2*MAP_CAPACITIES[0]);
g = obtest_new(1+3*MAP_CAPACITIES[0]);
h = obtest_new(1+4*MAP_CAPACITIES[0]);
assert(ob_hash((obj *)a)%MAP_CAPACITIES[0] == ob_hash((obj *)e)%MAP_CAPACITIES[0]);
assert(obmap_lookup(test_map, (obj *)a) == NULL);
obmap_insert(test_map, (obj *)a, (obj *)b);
test = (obtest *)obmap_lookup(test_map, (obj *)a);
assert(test);
assert(ob_compare((obj *)b, (obj *)test) == OB_EQUAL_TO);
assert(ob_reference_count((obj *)test) > 1);
obmap_insert(test_map, (obj *)e, (obj *)c);
obmap_insert(test_map, (obj *)f, (obj *)d);
obmap_insert(test_map, (obj *)g, (obj *)e);
obmap_insert(test_map, (obj *)h, (obj *)f);
test = (obtest *)obmap_lookup(test_map, (obj *)a);
assert(ob_compare((obj *)b, (obj *)test) == OB_EQUAL_TO);
assert(ob_compare((obj *)c, (obj *)test) != OB_EQUAL_TO);
test = (obtest *)obmap_lookup(test_map, (obj *)e);
assert(ob_compare((obj *)c, (obj *)test) == OB_EQUAL_TO);
assert(ob_compare((obj *)b, (obj *)test) != OB_EQUAL_TO);
test = (obtest *)obmap_lookup(test_map, (obj *)a);
obmap_insert(test_map, (obj *)a, NULL); /* remove binding of a -> b */
assert(obmap_lookup(test_map, (obj *)a) == NULL);
assert(ob_reference_count((obj *)test) == 1);
test = (obtest *)obmap_lookup(test_map, (obj *)h);
assert(ob_compare((obj *)f, (obj *)test) == OB_EQUAL_TO);
map_copy = obmap_copy(test_map);
obmap_insert(test_map, (obj *)e, NULL); /* remove binding of e -> c */
test = (obtest *)obmap_lookup(map_copy, (obj *)e);
assert(ob_compare((obj *)test, (obj *)c) == OB_EQUAL_TO);
obmap_remove(test_map, (obj *)e);
test = (obtest *)obmap_lookup(map_copy, (obj *)e);
assert(ob_compare((obj *)test, (obj *)c) == OB_EQUAL_TO);
test = (obtest *)obmap_lookup(test_map, (obj *)e);
assert(test == NULL);
assert(ob_hash((obj *)test_map) != ob_hash((obj *)map_copy));
assert(ob_compare((obj *)test_map, (obj *)map_copy) != OB_EQUAL_TO);
obmap_insert(test_map, (obj *)e, (obj *)c);
assert(ob_hash((obj *)test_map) == ob_hash((obj *)map_copy));
assert(ob_compare((obj *)test_map, (obj *)map_copy) == OB_EQUAL_TO);
obmap_clear(map_copy);
assert(obmap_lookup(map_copy, (obj *)e) == NULL);
assert(obmap_lookup(map_copy, (obj *)a) == NULL);
assert(obmap_lookup(map_copy, (obj *)f) == NULL);
for(i=0; i<ARRAY_SIZE; i++){
test_array[i] = obtest_new(i);
obmap_insert(test_map, (obj *)test_array[i], (obj *)test_array[i]);
}
for(i=0; i<ARRAY_SIZE; i++)
assert(ob_compare((obj *) test_array[i],
obmap_lookup(test_map, (obj *)test_array[i])) ==OB_EQUAL_TO);
ob_release((obj *)a);
ob_release((obj *)b);
ob_release((obj *)c);
ob_release((obj *)d);
ob_release((obj *)e);
ob_release((obj *)f);
ob_release((obj *)g);
ob_release((obj *)h);
ob_release((obj *)test_map);
ob_release((obj *)map_copy);
for(i=0; i<ARRAY_SIZE; i++)
ob_release((obj *)test_array[i]);
printf("obmap: TESTS PASSED\n");
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4038, %rsp # imm = 0x4038
callq 0x1bc0
movq %rax, %rbx
movl $0x1, %edi
callq 0x2774
movq %rax, %r14
movl $0x2, %edi
callq 0x2774
movq %rax, %r12
movl $0x3, %edi
callq 0x2774
movq %rax, 0x8(%rsp)
movl $0x195f3, %edi # imm = 0x195F3
callq 0x2774
movq %rax, 0x20(%rsp)
leaq 0x3eec(%rip), %rax # 0x53f0
movl (%rax), %r13d
leal 0x1(%r13), %edi
callq 0x2774
movq %rax, %rbp
leal 0x1(,%r13,2), %edi
callq 0x2774
movq %rax, (%rsp)
leal 0x1(%r13,%r13,2), %edi
callq 0x2774
movq %rax, 0x18(%rsp)
leal 0x1(,%r13,4), %edi
callq 0x2774
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0x3620
xorl %edx, %edx
divq %r13
movq %rdx, %r15
movq %rbp, %rdi
callq 0x3620
xorl %edx, %edx
divq %r13
cmpl %edx, %r15d
jne 0x1914
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2211
testq %rax, %rax
jne 0x1933
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1e27
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2211
testq %rax, %rax
movq 0x8(%rsp), %r13
je 0x1952
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
callq 0x365f
testb %al, %al
jne 0x1971
movq %r15, %rdi
callq 0x374e
cmpl $0x1, %eax
jbe 0x1990
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1e27
movq %rbx, %rdi
movq (%rsp), %r15
movq %r15, %rsi
movq 0x20(%rsp), %rdx
callq 0x1e27
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movq %rbp, %rdx
callq 0x1e27
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x1e27
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2211
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
callq 0x365f
testb %al, %al
jne 0x19af
movq %r13, %rdi
movq %r15, %rsi
callq 0x365f
testb %al, %al
je 0x19ce
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2211
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x365f
testb %al, %al
jne 0x19ed
movq %r12, %rdi
movq %r15, %rsi
callq 0x365f
testb %al, %al
je 0x1a0c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2211
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1e27
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2211
testq %rax, %rax
jne 0x1a2b
movq %r15, %rdi
callq 0x374e
cmpl $0x1, %eax
jne 0x1a4a
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x2211
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x365f
testb %al, %al
jne 0x1a69
movq %rbx, %rdi
callq 0x1c97
movq %rax, %r15
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x1e27
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2211
movq %rax, %rdi
movq %r13, %rsi
callq 0x365f
testb %al, %al
jne 0x1a88
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2265
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2211
movq %rax, %rdi
movq %r13, %rsi
callq 0x365f
testb %al, %al
jne 0x1aa7
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2211
testq %rax, %rax
jne 0x1ac6
movq %rbx, %rdi
callq 0x3620
movq %rax, %r13
movq %r15, %rdi
callq 0x3620
cmpq %rax, %r13
je 0x1ae5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x365f
testb %al, %al
movq 0x8(%rsp), %rdx
je 0x1b04
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x1e27
movq %rbx, %rdi
callq 0x3620
movq %rax, %r13
movq %r15, %rdi
callq 0x3620
cmpq %rax, %r13
jne 0x1b23
movq %rbx, %rdi
movq %r15, %rsi
callq 0x365f
testb %al, %al
jne 0x1b42
movq %r15, %rdi
callq 0x22ba
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2211
testq %rax, %rax
jne 0x1b61
movq %r15, %rdi
movq %r14, %rsi
callq 0x2211
testq %rax, %rax
jne 0x1b80
movq %r14, 0x28(%rsp)
movq %r15, %rdi
movq (%rsp), %rsi
callq 0x2211
testq %rax, %rax
jne 0x1b9f
movq %r12, %r14
xorl %r13d, %r13d
movl %r13d, %edi
callq 0x2774
movq %rax, 0x30(%rsp,%r13,8)
movq %rbx, %rdi
movq %rax, %rsi
movq %rax, %rdx
callq 0x1e27
incq %r13
cmpq $0x800, %r13 # imm = 0x800
jne 0x1809
xorl %r12d, %r12d
movq 0x30(%rsp,%r12,8), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2211
movq %r13, %rdi
movq %rax, %rsi
callq 0x365f
testb %al, %al
jne 0x18f5
incq %r12
cmpq $0x800, %r12 # imm = 0x800
jne 0x1833
movq 0x28(%rsp), %rdi
callq 0x36e2
movq %r14, %rdi
callq 0x36e2
movq 0x8(%rsp), %rdi
callq 0x36e2
movq 0x20(%rsp), %rdi
callq 0x36e2
movq %rbp, %rdi
callq 0x36e2
movq (%rsp), %rdi
callq 0x36e2
movq 0x18(%rsp), %rdi
callq 0x36e2
movq 0x10(%rsp), %rdi
callq 0x36e2
movq %rbx, %rdi
callq 0x36e2
movq %r15, %rdi
callq 0x36e2
xorl %ebx, %ebx
movq 0x30(%rsp,%rbx,8), %rdi
callq 0x36e2
incq %rbx
cmpq $0x800, %rbx # imm = 0x800
jne 0x18bf
leaq 0x3afa(%rip), %rdi # 0x53d6
callq 0x1040
xorl %eax, %eax
addq $0x4038, %rsp # imm = 0x4038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3a7c(%rip), %rdi # 0x5378
leaq 0x374c(%rip), %rsi # 0x504f
leaq 0x375c(%rip), %rcx # 0x5066
movl $0x6b, %edx
callq 0x1050
leaq 0x36e9(%rip), %rdi # 0x5004
leaq 0x372d(%rip), %rsi # 0x504f
leaq 0x373d(%rip), %rcx # 0x5066
movl $0x25, %edx
callq 0x1050
leaq 0x3737(%rip), %rdi # 0x5071
leaq 0x370e(%rip), %rsi # 0x504f
leaq 0x371e(%rip), %rcx # 0x5066
movl $0x27, %edx
callq 0x1050
leaq 0x3741(%rip), %rdi # 0x509a
leaq 0x36ef(%rip), %rsi # 0x504f
leaq 0x36ff(%rip), %rcx # 0x5066
movl $0x2c, %edx
callq 0x1050
leaq 0x3727(%rip), %rdi # 0x509f
leaq 0x36d0(%rip), %rsi # 0x504f
leaq 0x36e0(%rip), %rcx # 0x5066
movl $0x2d, %edx
callq 0x1050
leaq 0x3739(%rip), %rdi # 0x50d0
leaq 0x36b1(%rip), %rsi # 0x504f
leaq 0x36c1(%rip), %rcx # 0x5066
movl $0x2e, %edx
callq 0x1050
leaq 0x36e9(%rip), %rdi # 0x509f
leaq 0x3692(%rip), %rsi # 0x504f
leaq 0x36a2(%rip), %rcx # 0x5066
movl $0x36, %edx
callq 0x1050
leaq 0x371f(%rip), %rdi # 0x50f4
leaq 0x3673(%rip), %rsi # 0x504f
leaq 0x3683(%rip), %rcx # 0x5066
movl $0x37, %edx
callq 0x1050
leaq 0x3731(%rip), %rdi # 0x5125
leaq 0x3654(%rip), %rsi # 0x504f
leaq 0x3664(%rip), %rcx # 0x5066
movl $0x3b, %edx
callq 0x1050
leaq 0x3743(%rip), %rdi # 0x5156
leaq 0x3635(%rip), %rsi # 0x504f
leaq 0x3645(%rip), %rcx # 0x5066
movl $0x3c, %edx
callq 0x1050
leaq 0x363f(%rip), %rdi # 0x5071
leaq 0x3616(%rip), %rsi # 0x504f
leaq 0x3626(%rip), %rcx # 0x5066
movl $0x41, %edx
callq 0x1050
leaq 0x3736(%rip), %rdi # 0x5187
leaq 0x35f7(%rip), %rsi # 0x504f
leaq 0x3607(%rip), %rcx # 0x5066
movl $0x42, %edx
callq 0x1050
leaq 0x373c(%rip), %rdi # 0x51ac
leaq 0x35d8(%rip), %rsi # 0x504f
leaq 0x35e8(%rip), %rcx # 0x5066
movl $0x45, %edx
callq 0x1050
leaq 0x374e(%rip), %rdi # 0x51dd
leaq 0x35b9(%rip), %rsi # 0x504f
leaq 0x35c9(%rip), %rcx # 0x5066
movl $0x4b, %edx
callq 0x1050
leaq 0x372f(%rip), %rdi # 0x51dd
leaq 0x359a(%rip), %rsi # 0x504f
leaq 0x35aa(%rip), %rcx # 0x5066
movl $0x50, %edx
callq 0x1050
leaq 0x3741(%rip), %rdi # 0x520e
leaq 0x357b(%rip), %rsi # 0x504f
leaq 0x358b(%rip), %rcx # 0x5066
movl $0x54, %edx
callq 0x1050
leaq 0x372f(%rip), %rdi # 0x521b
leaq 0x355c(%rip), %rsi # 0x504f
leaq 0x356c(%rip), %rcx # 0x5066
movl $0x56, %edx
callq 0x1050
leaq 0x3745(%rip), %rdi # 0x5250
leaq 0x353d(%rip), %rsi # 0x504f
leaq 0x354d(%rip), %rcx # 0x5066
movl $0x57, %edx
callq 0x1050
leaq 0x3762(%rip), %rdi # 0x528c
leaq 0x351e(%rip), %rsi # 0x504f
leaq 0x352e(%rip), %rcx # 0x5066
movl $0x5b, %edx
callq 0x1050
leaq 0x3778(%rip), %rdi # 0x52c1
leaq 0x34ff(%rip), %rsi # 0x504f
leaq 0x350f(%rip), %rcx # 0x5066
movl $0x5c, %edx
callq 0x1050
leaq 0x3795(%rip), %rdi # 0x52fd
leaq 0x34e0(%rip), %rsi # 0x504f
leaq 0x34f0(%rip), %rcx # 0x5066
movl $0x60, %edx
callq 0x1050
leaq 0x379f(%rip), %rdi # 0x5326
leaq 0x34c1(%rip), %rsi # 0x504f
leaq 0x34d1(%rip), %rcx # 0x5066
movl $0x61, %edx
callq 0x1050
leaq 0x37a9(%rip), %rdi # 0x534f
leaq 0x34a2(%rip), %rsi # 0x504f
leaq 0x34b2(%rip), %rcx # 0x5066
movl $0x62, %edx
callq 0x1050
nop
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/tests/obmap_test.c
|
obmap_new_with_capacity
|
obmap * obmap_new_with_capacity(uint32_t capacity){
obmap *m = obmap_create_default();
uint32_t i = 0;
while(MAP_CAPACITIES[i] < capacity && i < NUM_CAPACITIES - 1) i++;
m->hash_table = obvector_new(MAP_CAPACITIES[i]);
m->pairs = obdeque_new();
m->cap_idx = i;
return m;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x3816(%rip), %r15 # 0x53f0
xorl %r14d, %r14d
callq 0x1c23
movq %rax, %rbx
movq %r14, %rax
movl (%r15), %edi
incq %r14
cmpq $0x18, %rax
ja 0x1bfc
addq $0x4, %r15
cmpl %ebp, %edi
jb 0x1be5
callq 0x2998
movq %rax, 0x10(%rbx)
callq 0x37c0
movq %rax, 0x18(%rbx)
decb %r14b
movb %r14b, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_create_default
|
obmap * obmap_create_default(void){
static const char classname[] = "obmap";
obmap *new_instance = malloc(sizeof(obmap));
assert(new_instance != NULL);
/* initialize base class data */
ob_init_base((obj *)new_instance, &obmap_destroy, &obmap_hash,
&obmap_compare, &obmap_display, classname);
new_instance->hash_table = NULL;
new_instance->pairs = NULL;
new_instance->cap_idx = 0;
new_instance->collisions = 0;
return new_instance;
}
|
pushq %rbx
movl $0x28, %edi
callq 0x10b0
testq %rax, %rax
je 0x1c78
movq %rax, %rbx
leaq 0x876(%rip), %rsi # 0x24b3
leaq 0x8d9(%rip), %rdx # 0x251d
leaq 0x9cc(%rip), %rcx # 0x2617
leaq 0xa9f(%rip), %r8 # 0x26f1
leaq 0x381a(%rip), %r9 # 0x5473
movq %rax, %rdi
callq 0x3534
movb $0x0, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movl $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x390c(%rip), %rdi # 0x558b
leaq 0x37fb(%rip), %rsi # 0x5481
leaq 0x3aaf(%rip), %rcx # 0x573c
movl $0x13b, %edx # imm = 0x13B
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_copy
|
obmap * obmap_copy(const obmap *to_copy){
obmap *copy;
obmap_pair *mp;
obdeque_iterator *it;
assert(to_copy);
copy = obmap_create_default();
copy->cap_idx = to_copy->cap_idx;
copy->collisions = to_copy->collisions;
copy->pairs = obdeque_new();
/* copy deque manually, internal objects need to be copied as well as Deque
* itself */
it = obdeque_head_iterator(to_copy->pairs);
if(it){
do{
mp = obmap_copy_pair((obmap_pair *)obdeque_obj_at_iterator(to_copy->pairs, it));
obdeque_add_at_tail(copy->pairs, (obj *)mp);
ob_release((obj *)mp);
}while(obdeque_iterate_next(to_copy->pairs, it));
}
ob_release((obj *)it);
obmap_rehash(copy); /* cannot grab to_copy->hash_table directly, stored
iterators must point to values within copy, not to copy */
return copy;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1d35
movq %rdi, %r14
callq 0x1c23
movq %rax, %rbx
movb 0x8(%r14), %al
movb %al, 0x8(%rbx)
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
callq 0x37c0
movq %rax, 0x18(%rbx)
movq 0x18(%r14), %rdi
callq 0x38dc
movq %rax, %r15
testq %rax, %rax
je 0x1d16
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x390a
movq %rax, %rdi
callq 0x1d54
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x398b
movq %r12, %rdi
callq 0x36e2
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x3a03
testb %al, %al
jne 0x1cdb
movq %r15, %rdi
callq 0x36e2
movq %rbx, %rdi
callq 0x1d89
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x373d(%rip), %rdi # 0x5479
leaq 0x373e(%rip), %rsi # 0x5481
leaq 0x374b(%rip), %rcx # 0x5495
movl $0x4d, %edx
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_rehash
|
void obmap_rehash(obmap *m){
obdeque_iterator *it, *it_copy;
assert(m);
ob_release((obj *)m->hash_table);
m->hash_table = obvector_new(MAP_CAPACITIES[m->cap_idx]);
it = obdeque_head_iterator(m->pairs);
if(!it) return;
do{
it_copy = obdeque_copy_iterator(it);
obmap_add_to_table(m, it_copy);
ob_release((obj *)it_copy);
}while(obdeque_iterate_next(m->pairs, it));
ob_release((obj *)it);
return;
}
|
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1e08
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x36e2
movzbl 0x8(%rbx), %eax
leaq 0x3646(%rip), %rcx # 0x53f0
movl (%rcx,%rax,4), %edi
callq 0x2998
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
callq 0x38dc
testq %rax, %rax
je 0x1e02
movq %rax, %r14
movq %r14, %rdi
callq 0x3baa
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x210b
movq %r15, %rdi
callq 0x36e2
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x3a03
testb %al, %al
jne 0x1dc7
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x36e2
popq %rbx
popq %r14
popq %r15
retq
leaq 0x36a7(%rip), %rdi # 0x54b6
leaq 0x366b(%rip), %rsi # 0x5481
leaq 0x3739(%rip), %rcx # 0x5556
movl $0xb4, %edx
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_insert
|
void obmap_insert(obmap *m, obj *key, obj *value){
obmap_pair *mp;
obdeque_iterator *it;
ob_hash_t hash_value;
assert(m);
hash_value = obmap_find_key(m, key);
it = (obdeque_iterator *)obvector_obj_at_index(m->hash_table, hash_value);
/* If the key already exists in the map then overwrite the existing
* value */
if(it){
mp = (obmap_pair *)obdeque_obj_at_iterator(m->pairs, it);
obmap_replace_pair_value(mp, value);
return;
}
/* if add operation will overload the map then resize the map */
if((obdeque_length(m->pairs)+1)/MAP_CAPACITIES[m->cap_idx] > MAX_LOAD_FACTOR)
obmap_increase_size(m);
mp = obmap_new_pair(key, value);
obdeque_add_at_tail(m->pairs, (obj *)mp);
ob_release((obj *)mp); /* map deque has only reference to mp */
assert(it = obdeque_tail_iterator(m->pairs));
obmap_add_to_table(m, it);
ob_release((obj *)it); /* map vector hash only reference to it */
return;
}
|
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1ede
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1f1c
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x2d97
movq 0x18(%rbx), %rdi
testq %rax, %rax
je 0x1e70
movq %rax, %rsi
callq 0x390a
movq %rax, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1fd2
callq 0x3ad6
incq %rax
movzbl 0x8(%rbx), %ecx
leaq 0x356d(%rip), %rdx # 0x53f0
movl (%rdx,%rcx,4), %ecx
cmpq %rcx, %rax
jb 0x1e93
movq %rbx, %rdi
callq 0x201d
movq %r15, %rdi
movq %r14, %rsi
callq 0x2088
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x398b
movq %r14, %rdi
callq 0x36e2
movq 0x18(%rbx), %rdi
callq 0x3b7c
testq %rax, %rax
je 0x1efd
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x210b
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x36e2
leaq 0x35d1(%rip), %rdi # 0x54b6
leaq 0x3595(%rip), %rsi # 0x5481
leaq 0x35c5(%rip), %rcx # 0x54b8
movl $0x6e, %edx
callq 0x1050
leaq 0x35dd(%rip), %rdi # 0x54e1
leaq 0x3576(%rip), %rsi # 0x5481
leaq 0x35a6(%rip), %rcx # 0x54b8
movl $0x83, %edx
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_find_key
|
ob_hash_t obmap_find_key(const obmap *m, const obj *key){
ob_hash_t hash_value, offset;
obmap_pair *mp;
obdeque_iterator *it;
hash_value = ob_hash(key)%MAP_CAPACITIES[m->cap_idx];
offset = 0;
while((it = (obdeque_iterator *)obvector_obj_at_index(m->hash_table, hash_value))){
mp = (obmap_pair *)obdeque_obj_at_iterator(m->pairs, it);
if(ob_compare(mp->key, key) == OB_EQUAL_TO)
break;
offset = obmap_offset_collision(offset);
hash_value = (hash_value+offset)%MAP_CAPACITIES[m->cap_idx];
}
return hash_value; /* the hash value where key is actually found */
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3620
movzbl 0x8(%r14), %ecx
leaq 0x34b1(%rip), %r12 # 0x53f0
movl (%r12,%rcx,4), %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, %r15
movq 0x10(%r14), %rdi
movq %rdx, %rsi
callq 0x2d97
testq %rax, %rax
je 0x1fc5
xorl %r13d, %r13d
movq 0x18(%r14), %rdi
movq %rax, %rsi
callq 0x390a
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x365f
testb %al, %al
je 0x1fc5
testq %r13, %r13
je 0x1f8e
cmpq $0x1, %r13
jne 0x1f96
movl $0x2, %r13d
jmp 0x1f9d
movl $0x1, %r13d
jmp 0x1f9d
imulq %r13, %r13
decq %r13
addq %r13, %r15
movzbl 0x8(%r14), %eax
movl (%r12,%rax,4), %ecx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq 0x10(%r14), %rdi
movq %rdx, %r15
movq %rdx, %rsi
callq 0x2d97
testq %rax, %rax
jne 0x1f5f
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_replace_pair_value
|
void obmap_replace_pair_value(obmap_pair *mp, obj *value){
assert(mp);
ob_retain(value);
ob_release(mp->value);
mp->value = value;
return;
}
|
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1ffe
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3717
movq 0x10(%r14), %rdi
callq 0x36e2
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x35c4(%rip), %rdi # 0x55c9
leaq 0x3475(%rip), %rsi # 0x5481
leaq 0x35e3(%rip), %rcx # 0x55f6
movl $0xf1, %edx
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_increase_size
|
void obmap_increase_size(obmap *to_size){
assert(to_size);
assert(to_size->cap_idx < NUM_CAPACITIES-1); /* cannot resize beyond largest
capacity */
to_size->cap_idx+=2;
if(to_size->cap_idx >= NUM_CAPACITIES) to_size->cap_idx = NUM_CAPACITIES-1;
to_size->collisions = 0; /* before resize reset collisions */
obmap_rehash(to_size);
}
|
pushq %rax
testq %rdi, %rdi
je 0x204a
movb 0x8(%rdi), %al
cmpb $0x19, %al
jae 0x2069
leal 0x2(%rax), %ecx
cmpb $0x18, %al
movzbl %cl, %eax
movl $0x19, %ecx
cmovnel %eax, %ecx
movb %cl, 0x8(%rdi)
movl $0x0, 0x20(%rdi)
popq %rax
jmp 0x1d89
leaq 0x3859(%rip), %rdi # 0x58aa
leaq 0x3429(%rip), %rsi # 0x5481
leaq 0x3853(%rip), %rcx # 0x58b2
movl $0x1a6, %edx # imm = 0x1A6
callq 0x1050
leaq 0x3864(%rip), %rdi # 0x58d4
leaq 0x340a(%rip), %rsi # 0x5481
leaq 0x3834(%rip), %rcx # 0x58b2
movl $0x1a7, %edx # imm = 0x1A7
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_new_pair
|
obmap_pair * obmap_new_pair(obj *key, obj *value){
static const char classname[] = "obmap_pair";
obmap_pair *new_instance = malloc(sizeof(obmap_pair));
assert(new_instance != NULL);
/* initialize base class data */
ob_init_base((obj *)new_instance, &obmap_destroy_pair, &obmap_hash_pair, NULL,
&obmap_display_pair, classname);
ob_retain(key);
new_instance->key = key;
ob_retain(value);
new_instance->value = value;
return new_instance;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x18, %edi
callq 0x10b0
testq %rax, %rax
je 0x20ec
movq %rax, %r14
leaq 0x26a(%rip), %rsi # 0x2316
leaq 0x2cd(%rip), %rdx # 0x2380
leaq 0x398(%rip), %r8 # 0x2452
leaq 0x33a7(%rip), %r9 # 0x5468
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x3534
movq %r15, %rdi
callq 0x3717
movq %r15, 0x8(%r14)
movq %rbx, %rdi
callq 0x3717
movq %rbx, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3498(%rip), %rdi # 0x558b
leaq 0x3387(%rip), %rsi # 0x5481
leaq 0x349f(%rip), %rcx # 0x55a0
movl $0xda, %edx
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_add_to_table
|
void obmap_add_to_table(obmap *m, obdeque_iterator *it){
ob_hash_t hash_value, offset;
obmap_pair *pair;
assert(m);
assert(it);
pair = (obmap_pair *)obdeque_obj_at_iterator(m->pairs, it);
hash_value = ob_hash(pair->key)%MAP_CAPACITIES[m->cap_idx];
offset = 0;
while(obvector_obj_at_index(m->hash_table, hash_value)){
offset = obmap_offset_collision(offset);
hash_value = (hash_value+offset)%MAP_CAPACITIES[m->cap_idx];
m->collisions++;
}
obvector_store_at_index(m->hash_table, (obj *)it, hash_value);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x21d3
movq %rsi, %rbx
testq %rsi, %rsi
je 0x21f2
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq %rbx, %rsi
callq 0x390a
movq 0x8(%rax), %rdi
callq 0x3620
movzbl 0x8(%r14), %ecx
leaq 0x32a3(%rip), %r12 # 0x53f0
movl (%r12,%rcx,4), %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, %r15
movq 0x10(%r14), %rdi
movq %rdx, %rsi
callq 0x2d97
testq %rax, %rax
je 0x21bb
xorl %r13d, %r13d
testq %r13, %r13
je 0x2180
cmpq $0x1, %r13
jne 0x2188
movl $0x2, %r13d
jmp 0x218f
movl $0x1, %r13d
jmp 0x218f
imulq %r13, %r13
decq %r13
addq %r13, %r15
movzbl 0x8(%r14), %eax
movl (%r12,%rax,4), %ecx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
incl 0x20(%r14)
movq 0x10(%r14), %rdi
movq %rdx, %r15
movq %rdx, %rsi
callq 0x2d97
testq %rax, %rax
jne 0x216d
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b21
leaq 0x32dc(%rip), %rdi # 0x54b6
leaq 0x32a0(%rip), %rsi # 0x5481
leaq 0x3710(%rip), %rcx # 0x58f8
movl $0x1b7, %edx # imm = 0x1B7
callq 0x1050
leaq 0x3734(%rip), %rdi # 0x592d
leaq 0x3281(%rip), %rsi # 0x5481
leaq 0x36f1(%rip), %rcx # 0x58f8
movl $0x1b8, %edx # imm = 0x1B8
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_lookup
|
obj * obmap_lookup(const obmap *m, const obj *key){
obdeque_iterator *it;
obmap_pair *mp;
ob_hash_t hash_value;
assert(m);
hash_value = obmap_find_key(m, key);
it = (obdeque_iterator *)obvector_obj_at_index(m->hash_table, hash_value);
if(!it) return NULL;
mp = (obmap_pair *)obdeque_obj_at_iterator(m->pairs, it);
return mp->value;
}
|
pushq %rbx
testq %rdi, %rdi
je 0x2246
movq %rdi, %rbx
callq 0x1f1c
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x2d97
testq %rax, %rax
je 0x2242
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x390a
movq 0x10(%rax), %rax
jmp 0x2244
xorl %eax, %eax
popq %rbx
retq
leaq 0x3269(%rip), %rdi # 0x54b6
leaq 0x322d(%rip), %rsi # 0x5481
leaq 0x32ab(%rip), %rcx # 0x5506
movl $0x91, %edx
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_remove
|
void obmap_remove(obmap *m, obj *key){
obdeque_iterator *it;
ob_hash_t hash_value;
assert(m);
hash_value = obmap_find_key(m, key);
it = (obdeque_iterator *)obvector_obj_at_index(m->hash_table, hash_value);
if(!it) return;
obdeque_remove_at_iterator(m->pairs, it);
obmap_rehash(m);
return;
}
|
pushq %rbx
testq %rdi, %rdi
je 0x229b
movq %rdi, %rbx
callq 0x1f1c
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x2d97
testq %rax, %rax
je 0x2299
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x4479
movq %rbx, %rdi
popq %rbx
jmp 0x1d89
popq %rbx
retq
leaq 0x3214(%rip), %rdi # 0x54b6
leaq 0x31d8(%rip), %rsi # 0x5481
leaq 0x3284(%rip), %rcx # 0x5534
movl $0xa2, %edx
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_clear
|
void obmap_clear(obmap *m){
assert(m);
ob_release((obj *)m->hash_table);
ob_release((obj *)m->pairs);
m->hash_table = obvector_new(MAP_CAPACITIES[m->cap_idx]);
m->pairs = obdeque_new();
}
|
pushq %rbx
testq %rdi, %rdi
je 0x22f7
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x36e2
movq 0x18(%rbx), %rdi
callq 0x36e2
movzbl 0x8(%rbx), %eax
leaq 0x3110(%rip), %rcx # 0x53f0
movl (%rcx,%rax,4), %edi
callq 0x2998
movq %rax, 0x10(%rbx)
callq 0x37c0
movq %rax, 0x18(%rbx)
popq %rbx
retq
leaq 0x31b8(%rip), %rdi # 0x54b6
leaq 0x317c(%rip), %rsi # 0x5481
leaq 0x3265(%rip), %rcx # 0x5571
movl $0xca, %edx
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_destroy_pair
|
void obmap_destroy_pair(obj *to_dealloc){
/* cast generic obj to obmap */
obmap_pair *instance = (obmap_pair *)to_dealloc;
assert(to_dealloc);
assert(ob_has_class(to_dealloc, "obmap_pair"));
ob_release((obj *)instance->key);
ob_release((obj *)instance->value);
return;
}
|
pushq %rbx
testq %rdi, %rdi
je 0x2342
movq %rdi, %rbx
leaq 0x3142(%rip), %rsi # 0x5468
callq 0x375c
testb %al, %al
je 0x2361
movq 0x8(%rbx), %rdi
callq 0x36e2
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x36e2
leaq 0x33a2(%rip), %rdi # 0x56eb
leaq 0x3131(%rip), %rsi # 0x5481
leaq 0x339f(%rip), %rcx # 0x56f6
movl $0x12a, %edx # imm = 0x12A
callq 0x1050
leaq 0x33ad(%rip), %rdi # 0x5715
leaq 0x3112(%rip), %rsi # 0x5481
leaq 0x3380(%rip), %rcx # 0x56f6
movl $0x12b, %edx # imm = 0x12B
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_hash_pair
|
ob_hash_t obmap_hash_pair(const obj *to_hash){
static int8_t init = 0;
static ob_hash_t seed = 0;
ob_hash_t value;
obmap_pair *instance = (obmap_pair *)to_hash;
assert(to_hash);
assert(ob_has_class(to_hash, "obmap_pair"));
if(init == 0){
srand(time(NULL));
seed = rand();
init = 1;
}
value = seed;
value += ob_hash(instance->key);
value += ob_hash(instance->value);
value += value << 3;
value ^= value >> 11;
value += value << 15;
return value;
}
|
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2414
movq %rdi, %rbx
leaq 0x30d0(%rip), %rsi # 0x5468
callq 0x375c
testb %al, %al
je 0x2433
cmpb $0x1, 0x6cdc(%rip) # 0x9088
jne 0x23b7
movq 0x6cdb(%rip), %r15 # 0x9090
jmp 0x23db
xorl %edi, %edi
callq 0x10a0
movl %eax, %edi
callq 0x1070
callq 0x10d0
movslq %eax, %r15
movq %r15, 0x6cbc(%rip) # 0x9090
movb $0x1, 0x6cad(%rip) # 0x9088
movq 0x8(%rbx), %rdi
callq 0x3620
movq %rax, %r14
addq %r15, %r14
movq 0x10(%rbx), %rdi
callq 0x3620
addq %r14, %rax
leaq (%rax,%rax,8), %rax
movq %rax, %rcx
shrq $0xb, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shlq $0xf, %rax
addq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x320e(%rip), %rdi # 0x5629
leaq 0x305f(%rip), %rsi # 0x5481
leaq 0x3208(%rip), %rcx # 0x5631
movl $0x101, %edx # imm = 0x101
callq 0x1050
leaq 0x321e(%rip), %rdi # 0x5658
leaq 0x3040(%rip), %rsi # 0x5481
leaq 0x31e9(%rip), %rcx # 0x5631
movl $0x102, %edx # imm = 0x102
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_display_pair
|
void obmap_display_pair(const obj *to_print){
obmap_pair *mp = (obmap_pair *)to_print;
assert(to_print != NULL);
assert(ob_has_class(to_print, "obmap_pair"));
fprintf(stderr, " [key]\n");
ob_display(mp->key);
fprintf(stderr, " [value]\n");
ob_display(mp->value);
return;
}
|
pushq %rbx
testq %rdi, %rdi
je 0x2475
movq %rdi, %rbx
leaq 0x3006(%rip), %rsi # 0x5468
callq 0x375c
testb %al, %al
je 0x2494
movq %rbx, %rdi
callq 0x10f0
popq %rbx
retq
leaq 0x3200(%rip), %rdi # 0x567c
leaq 0x2ffe(%rip), %rsi # 0x5481
leaq 0x3203(%rip), %rcx # 0x568d
movl $0x11a, %edx # imm = 0x11A
callq 0x1050
leaq 0x3217(%rip), %rdi # 0x56b2
leaq 0x2fdf(%rip), %rsi # 0x5481
leaq 0x31e4(%rip), %rcx # 0x568d
movl $0x11b, %edx # imm = 0x11B
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_destroy
|
void obmap_destroy(obj *to_dealloc){
/* cast generic obj to obmap */
obmap *instance = (obmap *)to_dealloc;
assert(to_dealloc);
assert(ob_has_class(to_dealloc, "obmap"));
ob_release((obj *)instance->hash_table);
ob_release((obj *)instance->pairs);
return;
}
|
pushq %rbx
testq %rdi, %rdi
je 0x24df
movq %rdi, %rbx
leaq 0x2fb0(%rip), %rsi # 0x5473
callq 0x375c
testb %al, %al
je 0x24fe
movq 0x10(%rbx), %rdi
callq 0x36e2
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x36e2
leaq 0x3205(%rip), %rdi # 0x56eb
leaq 0x2f94(%rip), %rsi # 0x5481
leaq 0x337a(%rip), %rcx # 0x586e
movl $0x19a, %edx # imm = 0x19A
callq 0x1050
leaq 0x3383(%rip), %rdi # 0x5888
leaq 0x2f75(%rip), %rsi # 0x5481
leaq 0x335b(%rip), %rcx # 0x586e
movl $0x19b, %edx # imm = 0x19B
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_hash
|
ob_hash_t obmap_hash(const obj *to_hash){
static int8_t init = 0;
static ob_hash_t seed = 0;
ob_hash_t value;
obdeque_iterator *it;
obmap *instance = (obmap *)to_hash;
assert(to_hash);
assert(ob_has_class(to_hash, "obmap"));
if(init == 0){
srand(time(NULL));
seed = rand();
init = 1;
}
value = seed;
it = obdeque_head_iterator(instance->pairs);
if(!it) return value;
/* perform commutative hash, so order of addition to table does not matter */
do{
value += ob_hash(obdeque_obj_at_iterator(instance->pairs, it));
}while(obdeque_iterate_next(instance->pairs, it));
ob_release((obj *)it);
value += value << 3;
value ^= value >> 11;
value += value << 15;
return value;
}
|
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x25d9
movq %rdi, %rbx
leaq 0x2f3e(%rip), %rsi # 0x5473
callq 0x375c
testb %al, %al
je 0x25f8
cmpb $0x1, 0x6b4f(%rip) # 0x9098
jne 0x2554
movq 0x6b4e(%rip), %r14 # 0x90a0
jmp 0x2578
xorl %edi, %edi
callq 0x10a0
movl %eax, %edi
callq 0x1070
callq 0x10d0
movslq %eax, %r14
movq %r14, 0x6b2f(%rip) # 0x90a0
movb $0x1, 0x6b20(%rip) # 0x9098
movq 0x18(%rbx), %rdi
callq 0x38dc
testq %rax, %rax
je 0x25d0
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x390a
movq %rax, %rdi
callq 0x3620
addq %rax, %r14
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x3a03
testb %al, %al
jne 0x2589
movq %r15, %rdi
callq 0x36e2
leaq (%r14,%r14,8), %rax
movq %rax, %rcx
shrq $0xb, %rcx
xorq %rax, %rcx
movq %rcx, %r14
shlq $0xf, %r14
addq %rcx, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3049(%rip), %rdi # 0x5629
leaq 0x2e9a(%rip), %rsi # 0x5481
leaq 0x3170(%rip), %rcx # 0x575e
movl $0x153, %edx # imm = 0x153
callq 0x1050
leaq 0x3181(%rip), %rdi # 0x5780
leaq 0x2e7b(%rip), %rsi # 0x5481
leaq 0x3151(%rip), %rcx # 0x575e
movl $0x154, %edx # imm = 0x154
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_compare
|
int8_t obmap_compare(const obj *a, const obj *b){
assert(a);
assert(b);
assert(ob_has_class(a, "obmap"));
assert(ob_has_class(b, "obmap"));
if(ob_hash(a) == ob_hash(b)) return OB_EQUAL_TO;
return OB_NOT_EQUAL;
}
|
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2675
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2694
movq %rdi, %r14
leaq 0x2e41(%rip), %rsi # 0x5473
callq 0x375c
testb %al, %al
je 0x26b3
leaq 0x2e31(%rip), %rsi # 0x5473
movq %rbx, %rdi
callq 0x375c
testb %al, %al
je 0x26d2
movq %r14, %rdi
callq 0x3620
movq %rax, %r14
movq %rbx, %rdi
callq 0x3620
cmpq %rax, %r14
setne %al
addb %al, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3123(%rip), %rdi # 0x579f
leaq 0x2dfe(%rip), %rsi # 0x5481
leaq 0x3117(%rip), %rcx # 0x57a1
movl $0x172, %edx # imm = 0x172
callq 0x1050
leaq 0x3135(%rip), %rdi # 0x57d0
leaq 0x2ddf(%rip), %rsi # 0x5481
leaq 0x30f8(%rip), %rcx # 0x57a1
movl $0x173, %edx # imm = 0x173
callq 0x1050
leaq 0x3118(%rip), %rdi # 0x57d2
leaq 0x2dc0(%rip), %rsi # 0x5481
leaq 0x30d9(%rip), %rcx # 0x57a1
movl $0x174, %edx # imm = 0x174
callq 0x1050
leaq 0x3112(%rip), %rdi # 0x57eb
leaq 0x2da1(%rip), %rsi # 0x5481
leaq 0x30ba(%rip), %rcx # 0x57a1
movl $0x175, %edx # imm = 0x175
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
obmap_display
|
void obmap_display(const obj *to_print){
obmap *m = (obmap *)to_print;
obdeque_iterator *it;
assert(to_print != NULL);
assert(ob_has_class(to_print, "obmap"));
fprintf(stderr, "obmap with key-value pairs:\n");
it = obdeque_head_iterator(m->pairs);
if(!it) return;
do{
ob_display(obdeque_obj_at_iterator(m->pairs, it));
}while(obdeque_iterate_next(m->pairs, it));
fprintf(stderr, " [map end]\n");
ob_release((obj *)it);
return;
}
|
pushq %rbx
testq %rdi, %rdi
je 0x2714
movq %rdi, %rbx
leaq 0x2d72(%rip), %rsi # 0x5473
callq 0x375c
testb %al, %al
je 0x2733
movq %rbx, %rdi
callq 0x1144
popq %rbx
retq
leaq 0x2f61(%rip), %rdi # 0x567c
leaq 0x2d5f(%rip), %rsi # 0x5481
leaq 0x30db(%rip), %rcx # 0x5804
movl $0x181, %edx # imm = 0x181
callq 0x1050
leaq 0x30ea(%rip), %rdi # 0x5824
leaq 0x2d40(%rip), %rsi # 0x5481
leaq 0x30bc(%rip), %rcx # 0x5804
movl $0x182, %edx # imm = 0x182
callq 0x1050
|
/workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obmap.c
|
gen_addr
|
static void gen_addr(Node *node) {
// switchの警告を消すpragma
#pragma clang diagnostic ignored "-Wswitch"
switch(node->kind) {
case ND_VAR:
printfln(" # gen_addr start (var_name: %s, var_type: %s)", node->var->name, node->var->is_local ? "local" : "global");
printfln(" # gen_addr-ND_VAR start");
// compound_literaruの場合 この アドレス参照時のvarノードで初めて初期化されるので、そのチェック
// &(int) { 1 } みたいなケース
if (node->init) {
gen(node->init);
}
if (node->var->is_local) {
printfln(" mov rax, rbp");
printfln(" sub rax, %d", node->var->offset);
printfln(" push rax");
} else {
// global変数の場合は単にそのラベル(=変数名)をpushする
printfln(" push offset %s", node->var->name);
}
printfln(" # gen_addr-ND_VAR end");
printfln(" # gen_addr end");
return;
case ND_DEREF:
printfln(" # gen_addr start (var_name: none)");
printfln(" # gen_addr-ND_DEREF start");
gen(node->lhs);
printfln(" # gen_addr-ND_DEREF stop");
printfln(" # gen_addr end");
return;
case ND_MEMBER:
printfln(" # gen_addr start (struct-member: %s)", node->member->name);
printfln(" # gen_addr-ND_MEMBER start");
printfln(" # struct var ref start");
gen_addr(node->lhs);
printfln(" # struct var ref end");
printfln(" # struct member ref start");
printfln(" pop rax"); // 構造体変数のアドレス
printfln(" add rax, %d", node->member->offset); //構造体のアドレスを元にそのメンバーの位置(オフセットを設定)
printfln(" push rax"); // 構造体メンバーのアドレスをpush
printfln(" # struct member ref end");
printfln(" # gen_addr-ND_MEMBER stop");
printfln(" # gen_addr end");
return;
}
error("代入の左辺値が変数ではありません");
}
|
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x23, %eax
je 0x38b2
cmpl $0x1f, %eax
je 0x3881
cmpl $0x17, %eax
jne 0x3957
movq 0x78(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0x833f(%rip), %rcx # 0xbb43
leaq 0x833e(%rip), %rdx # 0xbb49
cmpb $0x0, 0x14(%rax)
cmovneq %rcx, %rdx
leaq 0x82f9(%rip), %rdi # 0xbb13
xorl %eax, %eax
callq 0x27b5
leaq 0x8328(%rip), %rdi # 0xbb50
xorl %eax, %eax
callq 0x27b5
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x383d
callq 0x2847
movq 0x78(%rbx), %rax
cmpb $0x1, 0x14(%rax)
jne 0x3966
leaq 0x8318(%rip), %rdi # 0xbb6a
xorl %eax, %eax
callq 0x27b5
movq 0x78(%rbx), %rax
movl 0x10(%rax), %esi
leaq 0x8312(%rip), %rdi # 0xbb79
xorl %eax, %eax
callq 0x27b5
leaq 0x7b3e(%rip), %rdi # 0xb3b3
xorl %eax, %eax
callq 0x27b5
jmp 0x3978
leaq 0x8339(%rip), %rdi # 0xbbc1
xorl %eax, %eax
callq 0x27b5
leaq 0x834f(%rip), %rdi # 0xbbe5
xorl %eax, %eax
callq 0x27b5
movq 0x18(%rbx), %rdi
callq 0x2847
leaq 0x8354(%rip), %rdi # 0xbc01
jmp 0x397f
movq 0x98(%rbx), %rax
movq 0x10(%rax), %rsi
leaq 0x8358(%rip), %rdi # 0xbc1c
xorl %eax, %eax
callq 0x27b5
leaq 0x8371(%rip), %rdi # 0xbc43
xorl %eax, %eax
callq 0x27b5
leaq 0x8380(%rip), %rdi # 0xbc60
xorl %eax, %eax
callq 0x27b5
movq 0x18(%rbx), %rdi
callq 0x37d4
leaq 0x8382(%rip), %rdi # 0xbc79
xorl %eax, %eax
callq 0x27b5
leaq 0x838b(%rip), %rdi # 0xbc90
xorl %eax, %eax
callq 0x27b5
leaq 0x7b55(%rip), %rdi # 0xb468
xorl %eax, %eax
callq 0x27b5
movq 0x98(%rbx), %rax
movl 0x18(%rax), %esi
leaq 0x8381(%rip), %rdi # 0xbcac
xorl %eax, %eax
callq 0x27b5
leaq 0x7a7a(%rip), %rdi # 0xb3b3
xorl %eax, %eax
callq 0x27b5
leaq 0x8373(%rip), %rdi # 0xbcba
xorl %eax, %eax
callq 0x27b5
leaq 0x837f(%rip), %rdi # 0xbcd4
jmp 0x397f
leaq 0x8392(%rip), %rdi # 0xbcf0
xorl %eax, %eax
popq %rbx
jmp 0x4a3b
movq 0x8(%rax), %rsi
leaq 0x8216(%rip), %rdi # 0xbb87
xorl %eax, %eax
callq 0x27b5
leaq 0x8219(%rip), %rdi # 0xbb98
xorl %eax, %eax
callq 0x27b5
leaq 0x8223(%rip), %rdi # 0xbbb0
xorl %eax, %eax
popq %rbx
jmp 0x27b5
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/codegen.c
|
load
|
static void load(Type *t) {
printfln(" pop rax"); // スタックにつまれている、変数のアドレスをraxにロード
// 変数のアドレスにある値をraxにロード
int sz = t->size;
if (sz == 1) {
printfln(" movsx rax, BYTE PTR [rax]");
} else if (sz == 2) {
printfln(" movsx rax, WORD PTR [rax]");
} else if (sz == 4) {
printfln(" movsxd rax, DWORD PTR [rax]");
} else if (sz == 8) {
printfln(" mov rax, [rax]");
} else {
assert(false);
}
printfln(" push rax"); // 変数の値(rax)をスタックに積む
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x7ac8(%rip), %rdi # 0xb468
xorl %eax, %eax
callq 0x27b5
movl 0x4(%rbx), %eax
decl %eax
cmpl $0x8, %eax
jae 0x39e1
movl $0x8b, %ecx
btl %eax, %ecx
jae 0x39e1
movl %eax, %eax
leaq 0x7790(%rip), %rcx # 0xb154
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
xorl %eax, %eax
callq 0x27b5
leaq 0x79da(%rip), %rdi # 0xb3b3
xorl %eax, %eax
popq %rbx
jmp 0x27b5
leaq 0x793a(%rip), %rdi # 0xb322
leaq 0x790b(%rip), %rsi # 0xb2fa
leaq 0x8392(%rip), %rcx # 0xbd88
movl $0x27, %edx
callq 0x20d0
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/codegen.c
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.