name string | code string | asm string | file string |
|---|---|---|---|
sldict_init | void
sldict_init(
ion_dictionary_handler_t *handler
) {
handler->insert = sldict_insert;
handler->get = sldict_get;
handler->create_dictionary = sldict_create_dictionary;
handler->remove = sldict_delete;
handler->delete_dictionary = sldict_delete_dictionary;
handler->destroy_dictionary = sldict_destroy_... | leaq 0x67(%rip), %rax # 0x541c
movq %rax, (%rdi)
leaq -0x327(%rip), %rax # 0x5098
movq %rax, 0x10(%rdi)
leaq 0x5b(%rip), %rax # 0x5425
movq %rax, 0x8(%rdi)
leaq 0xd0(%rip), %rax # 0x54a5
movq %rax, 0x28(%rdi)
leaq 0xce(%rip), %rax # 0x54ae
movq %rax, 0x30(%rdi)
leaq 0xeb(%rip), %rax ... | /iondbproject[P]iondb/src/dictionary/skip_list/skip_list_handler.c |
sldict_create_dictionary | ion_err_t
sldict_create_dictionary(
ion_dictionary_id_t id,
ion_key_type_t key_type,
ion_key_size_t key_size,
ion_value_size_t value_size,
ion_dictionary_size_t dictionary_size,
ion_dictionary_compare_t compare,
ion_dictionary_handler_t *handler,
ion_dictionary_t *dictionary
) {
UNUSED(id);
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq 0x48(%rsp), %r13
pushq $0x38
popq %rdi
callq 0x1160
movq %rax, 0x8(%r13)
testq %rax, %rax
je 0x5494
movq %r12, 0x10(%rax)
pushq $0x4
popq %rcx
movl %ecx, 0x1... | /iondbproject[P]iondb/src/dictionary/skip_list/skip_list_handler.c |
dictionary_switch_compare | ion_dictionary_compare_t
dictionary_switch_compare(
ion_key_type_t key_type
) {
ion_dictionary_compare_t compare;
switch (key_type) {
case key_type_numeric_signed: {
compare = dictionary_compare_signed_value;
break;
}
case key_type_numeric_unsigned: {
compare = dictionary_compare_unsigned_value;
... | decl %edi
cmpl $0x2, %edi
ja 0x552b
movl %edi, %eax
leaq 0xe8b2(%rip), %rcx # 0x13dd8
movq (%rcx,%rax,8), %rax
retq
leaq 0x1(%rip), %rax # 0x5533
retq
| /iondbproject[P]iondb/src/dictionary/dictionary.c |
dictionary_create | ion_err_t
dictionary_create(
ion_dictionary_handler_t *handler,
ion_dictionary_t *dictionary,
ion_dictionary_id_t id,
ion_key_type_t key_type,
ion_key_size_t key_size,
ion_value_size_t value_size,
ion_dictionary_size_t dictionary_size
) {
ion_err_t err;
ion_dictionary_compare_t compare = dicti... | pushq %rbp
pushq %rbx
pushq %rax
movl %r9d, %r11d
movl %r8d, %r10d
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %rax
movl 0x20(%rsp), %r8d
leal -0x1(%rcx), %edx
cmpl $0x2, %edx
ja 0x55b3
movl %edx, %edx
leaq 0xe82b(%rip), %rsi # 0x13dd8
movq (%rsi,%rdx,8), %r9
jmp 0x55ba
leaq -0x87(%rip), %r9 # 0x5533
movl %e... | /iondbproject[P]iondb/src/dictionary/dictionary.c |
dictionary_open | ion_err_t
dictionary_open(
ion_dictionary_handler_t *handler,
ion_dictionary_t *dictionary,
ion_dictionary_config_info_t *config
) {
ion_dictionary_compare_t compare = dictionary_switch_compare(config->type);
ion_err_t error = handler->open_dictionary(handler, dictionary, config, compare);
if (err_not_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdx), %eax
decl %eax
cmpl $0x2, %eax
ja 0x5660
movl %eax, %eax
leaq 0xe77e(%rip), %rcx # 0x13dd8
movq (%rcx,%rax,8), %rcx
jmp 0x5667
leaq -0x134(%rip), %rcx # 0x553... | /iondbproject[P]iondb/src/dictionary/dictionary.c |
dictionary_build_predicate | ion_err_t
dictionary_build_predicate(
ion_predicate_t *predicate,
ion_predicate_type_t type,
...
) {
va_list arg_list;
va_start(arg_list, type);
predicate->type = type;
switch (type) {
case predicate_equality: {
ion_key_t key = va_arg(arg_list, ion_key_t);
predicate->statement.equality.equality_val... | subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x584c
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%... | /iondbproject[P]iondb/src/dictionary/dictionary.c |
dictionary_close | ion_err_t
dictionary_close(
ion_dictionary_t *dictionary
) {
if (ion_dictionary_status_closed == dictionary->status) {
return err_ok;
}
ion_err_t error = dictionary->handler->close_dictionary(dictionary);
if (err_not_implemented == error) {
ion_predicate_t predicate;
ion_dict_cursor_t *cursor = NULL;
io... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
cmpb $0x1, (%rdi)
je 0x5abf
movq %rdi, %rbx
movq 0x10(%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0x5abc
movl %eax, %r14d
movzbl %al, %eax
cmpl $0xf, %eax
jne 0x5ac2
leaq -0x30(%rbp), %r14
andq $0x0, (%r14)
leaq -0x78... | /iondbproject[P]iondb/src/dictionary/dictionary.c |
sl_destroy | ion_err_t
sl_destroy(
ion_skiplist_t *skiplist
) {
ion_sl_node_t *cursor = skiplist->head, *tofree;
while (cursor != NULL) {
tofree = cursor;
cursor = cursor->next[0];
free(tofree->key);
free(tofree->value);
free(tofree->next);
free(tofree);
}
skiplist->head = NULL;
return err_ok;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x5c92
movq (%r14), %rdi
movq 0x18(%r14), %rax
movq (%rax), %r15
callq 0x1030
movq 0x8(%r14), %rdi
callq 0x1030
movq 0x18(%r14), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r15, %r14
jmp 0x5c5f
andq $0x0, 0x20(%rbx)
xorl... | /iondbproject[P]iondb/src/dictionary/skip_list/skip_list.c |
sl_insert | ion_status_t
sl_insert(
ion_skiplist_t *skiplist,
ion_key_t key,
ion_value_t value
) {
ion_key_size_t key_size = skiplist->super.record.key_size;
ion_value_size_t value_size = skiplist->super.record.value_size;
ion_sl_node_t *newnode = malloc(sizeof(ion_sl_node_t));
if (NULL == newnode) {
return ION_STA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r15
movslq 0x4(%rdi), %r12
movslq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
pushq $0x20
popq %rdi
callq 0x1160
pushq $0x6
popq %r13
testq %rax, %rax
je 0x5e26
movq %rax, %rbx
movq %rbp, 0x10(%rsp)
m... | /iondbproject[P]iondb/src/dictionary/skip_list/skip_list.c |
sl_find_node | ion_sl_node_t *
sl_find_node(
ion_skiplist_t *skiplist,
ion_key_t key
) {
int key_size = skiplist->super.record.key_size;
ion_sl_node_t *cursor = skiplist->head;
ion_sl_level_t h;
for (h = skiplist->head->height; h >= 0; h--) {
while (NULL != cursor->next[h] && skiplist->super.compare(cursor->next[h]->key... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %ebp
movq 0x20(%rdi), %r12
movl 0x10(%r12), %r15d
testl %r15d, %r15d
js 0x5f34
movl %r15d, %r13d
movq %r12, %rax
movq %rax, %r12
movq 0x18(%rax), %rax
movq (%rax,%r13,8), %rax
testq %rax, %rax
je... | /iondbproject[P]iondb/src/dictionary/skip_list/skip_list.c |
sl_update | ion_status_t
sl_update(
ion_skiplist_t *skiplist,
ion_key_t key,
ion_value_t value
) {
ion_status_t status;
status = ION_STATUS_INITIALIZE;
ion_key_size_t key_size = skiplist->super.record.key_size;
ion_value_size_t value_size = skiplist->super.record.value_size;
ion_sl_node_t *cursor = sl_find_node(skip... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, (%rsp)
movl 0x4(%rdi), %r13d
movslq 0x8(%rdi), %r12
callq 0x5eb7
movq (%rax), %rdi
testq %rdi, %rdi
je 0x6034
movq %rax, %rbp
movq %... | /iondbproject[P]iondb/src/dictionary/skip_list/skip_list.c |
sl_delete | ion_status_t
sl_delete(
ion_skiplist_t *skiplist,
ion_key_t key
) {
ion_key_size_t key_size = skiplist->super.record.key_size;
/* Default return is no item */
ion_status_t status;
status = ION_STATUS_INITIALIZE;
/* If we fall through, then we didn't find what we were looking for. */
status.error = err_item_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %ebp
movq 0x20(%rdi), %r12
movl 0x10(%r12), %eax
movq $0x0, 0x8(%rsp)
movb $0x1, %r15b
testl %eax, %eax
js 0x61c1
movl %eax, 0x14(%rsp)
movl %eax, %r13d
movq %r12, %rcx
movq %rcx, %r12
movq... | /iondbproject[P]iondb/src/dictionary/skip_list/skip_list.c |
ffdict_next | ion_cursor_status_t
ffdict_next(
ion_dict_cursor_t *cursor,
ion_record_t *record
) {
ion_flat_file_t *flat_file = (ion_flat_file_t *) cursor->dictionary->instance;
ion_flat_file_cursor_t *flat_file_cursor = (ion_flat_file_cursor_t *) cursor;
if (cursor->status == cs_cursor_uninitialized) {
return cursor->s... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movzbl (%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
ja 0x6329
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movq 0x8(%rdx), %r15
leaq 0x76ab(%rip), %rdx # 0xd940
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb $0x4, (%rbx)
movq 0x28(%rbx), %... | /iondbproject[P]iondb/src/dictionary/flat_file/flat_file_dictionary_handler.c |
ffdict_create_dictionary | ion_err_t
ffdict_create_dictionary(
ion_dictionary_id_t id,
ion_key_type_t key_type,
ion_key_size_t key_size,
ion_value_size_t value_size,
ion_dictionary_size_t dictionary_size,
ion_dictionary_compare_t compare,
ion_dictionary_handler_t *handler,
ion_dictionary_t *dictionary
) {
dictionary->instan... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movl %r8d, 0x4(%rsp)
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movl %edi, %r13d
movq 0x48(%rsp), %rbx
pushq $0x68
popq %rdi
callq 0x1160
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x6450
movq 0x40(%rsp), %rbx
movq %r12, 0x... | /iondbproject[P]iondb/src/dictionary/flat_file/flat_file_dictionary_handler.c |
ffdict_close_dictionary | ion_err_t
ffdict_close_dictionary(
ion_dictionary_t *dictionary
) {
ion_err_t err = flat_file_close((ion_flat_file_t *) dictionary->instance);
free(dictionary->instance);
dictionary->instance = NULL;
if (err_ok != err) {
return err;
}
return err_ok;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6c5d
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0x1030
andq $0x0, 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /iondbproject[P]iondb/src/dictionary/flat_file/flat_file_dictionary_handler.c |
ffdict_init | void
ffdict_init(
ion_dictionary_handler_t *handler
) {
handler->insert = ffdict_insert;
handler->create_dictionary = ffdict_create_dictionary;
handler->get = ffdict_get;
handler->update = ffdict_update;
handler->find = ffdict_find;
handler->remove = ffdict_delete;
handler->delete_dictionary = ff... | leaq 0x67(%rip), %rax # 0x6716
movq %rax, (%rdi)
leaq -0x2e2(%rip), %rax # 0x63d7
movq %rax, 0x8(%rdi)
leaq 0x5b(%rip), %rax # 0x671f
movq %rax, 0x10(%rdi)
leaq 0x59(%rip), %rax # 0x6728
movq %rax, 0x18(%rdi)
leaq -0x251(%rip), %rax # 0x6489
movq %rax, 0x20(%rdi)
leaq 0x4c(%rip), %rax ... | /iondbproject[P]iondb/src/dictionary/flat_file/flat_file_dictionary_handler.c |
flat_file_predicate_within_bounds | ion_boolean_t
flat_file_predicate_within_bounds(
ion_flat_file_t *flat_file,
ion_flat_file_row_t *row,
va_list *args
) {
ion_key_t lower_bound = va_arg(*args, ion_key_t);
ion_key_t upper_bound = va_arg(*args, ion_key_t);
return ION_FLAT_FILE_STATUS_OCCUPIED == row->row_status && flat_file->super.compare(row-... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %ecx
cmpq $0x29, %rcx
jae 0x6cfb
movq 0x10(%rdx), %rsi
movq %rcx, %rax
addq $0x8, %rax
movl %eax, (%rdx)
movq (%rsi,%rcx), %rsi
cmpl $0x20, %ecx
ja 0x6d0a
addq 0x10(%rdx), %rax
addl $0x10, %ecx
movl %ecx, (%rdx)
jmp 0x6d16
movq 0x8(%rdx), %ra... | /iondbproject[P]iondb/src/dictionary/flat_file/flat_file.c |
flat_file_read_row | ion_err_t
flat_file_read_row(
ion_flat_file_t *flat_file,
ion_fpos_t location,
ion_flat_file_row_t *row
) {
ion_fpos_t read_index = 0;
if ((flat_file->current_loaded_region != -1) && (location >= flat_file->current_loaded_region) && ((unsigned) location < flat_file->current_loaded_region + flat_file->num_in_bu... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x58(%rdi), %rcx
cmpq $-0x1, %rcx
sete %dl
movq %rsi, %rax
subq %rcx, %rax
setl %dil
orb %dl, %dil
jne 0x6e3a
movl %esi, %edx
addq 0x60(%r14), %rcx
cmpq %rcx, %rdx
jae 0x6e3a
movq 0x40(%r14), %rcx
imulq 0x50(%r14), %rax
leaq (%rcx,%rax), %rdx
addq %r... | /iondbproject[P]iondb/src/dictionary/flat_file/flat_file.c |
oah_initialize | ion_err_t
oah_initialize(
ion_hashmap_t *hashmap,
ion_hash_t (*hashing_function)(ion_hashmap_t *, ion_key_t, int),
ion_key_type_t key_type,
ion_key_size_t key_size,
ion_value_size_t value_size,
int size
) {
int i;
hashmap->write_concern = wc_insert_unique; /* By default allow unique inserts only */
hashm... | pushq %r15
pushq %r14
pushq %rbx
movl %r9d, %ebx
movq %rsi, %r15
movq %rdi, %r14
movb $0x1, 0x24(%rdi)
movl %ecx, 0x4(%rdi)
movl %r8d, 0x8(%rdi)
movl %edx, (%rdi)
movl %r9d, 0x20(%rdi)
leal (%rcx,%r8), %eax
incl %eax
imull %r9d, %eax
movslq %eax, %rdi
callq 0x1160
movq %rax, 0x30(%r14)
movq %r15, 0x28(%r14)
testq %rax,... | /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash.c |
oah_get | ion_status_t
oah_get(
ion_hashmap_t *hash_map,
ion_key_t key,
ion_value_t value
) {
int loc;
if (oah_find_item_loc(hash_map, key, &loc) == err_ok) {
#if ION_DEBUG
printf("Item found at location %d\n", loc);
#endif
int data_length = hash_map->super.record.key_size + hash_map->super.record.value_size;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x4(%rsp), %rdx
callq 0x7a08
testb %al, %al
je 0x7b03
pushq $0x1
popq %rax
jmp 0x7b39
movslq 0x4(%r14), %rax
movslq 0x8(%r14), %rdx
leal (%rax,%rdx), %ecx
incl %ecx
movslq 0x4(%rsp), %rsi
movslq %ecx, %rcx
imulq %rsi, %rcx
addq 0x30(%r14), %rcx
leaq ... | /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash.c |
oafh_get | ion_status_t
oafh_get(
ion_file_hashmap_t *hash_map,
ion_key_t key,
ion_value_t value
) {
int loc;
if (oafh_find_item_loc(hash_map, key, &loc) == err_ok) {
#if ION_DEBUG
printf("Item found at location %d\n", loc);
#endif
int record_size = hash_map->super.record.key_size + hash_map->super.record.value_siz... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x4(%rsp), %rdx
callq 0x84af
testb %al, %al
je 0x86ad
pushq $0x1
popq %rax
jmp 0x86ec
movl 0x4(%r14), %eax
leal 0x1(%rax), %ecx
addl 0x8(%r14), %ecx
movq 0x30(%r14), %rdi
imull 0x4(%rsp), %ecx
addl %ecx, %eax
incl %eax
movslq %eax, %rsi
xorl %edx, %e... | /iondbproject[P]iondb/src/dictionary/open_address_file_hash/open_address_file_hash.c |
bpptree_close_dictionary | ion_err_t
bpptree_close_dictionary(
ion_dictionary_t *dictionary
) {
ion_bpptree_t *bpptree;
ion_bpp_err_t bErr;
bpptree = (ion_bpptree_t *) dictionary->instance;
bErr = b_close(bpptree->tree);
ion_fclose(bpptree->values.file_handle);
free(dictionary->instance);
dictionary->instance = NULL;
if (bErrO... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x20(%r14), %rdi
callq 0x95be
testl %eax, %eax
setne %bpl
movq 0x28(%r14), %rdi
callq 0x90fb
movq 0x8(%rbx), %rdi
callq 0x1030
andq $0x0, 0x8(%rbx)
shlb $0x2, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /iondbproject[P]iondb/src/dictionary/bpp_tree/bpp_tree_handler.c |
bpptree_find | ion_err_t
bpptree_find(
ion_dictionary_t *dictionary,
ion_predicate_t *predicate,
ion_dict_cursor_t **cursor
) {
ion_bpptree_t *bpptree = (ion_bpptree_t *) dictionary->instance;
ion_key_size_t key_size = dictionary->instance->record.key_size;
*cursor = malloc(sizeof(ion_bpp_cursor_t));
if (NULL == *cursor) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movslq 0x4(%r15), %r13
pushq $0x38
popq %rdi
callq 0x1160
movq %rax, (%r12)
movb $0x6, %dl
testq %rax, %rax
je 0x8dec
movq %rax, %r14
movq %r12, 0x8(%rsp)
movq %r13, %r... | /iondbproject[P]iondb/src/dictionary/bpp_tree/bpp_tree_handler.c |
lfb_update_all | ion_err_t
lfb_update_all(
ion_lfb_t *bag,
ion_file_offset_t offset,
unsigned int num_bytes,
ion_byte_t *to_write,
ion_result_count_t *count
) {
ion_err_t error;
ion_file_offset_t next;
while (ION_LFB_NULL != offset) {
error = ion_fread_at(bag->file_handle, offset, sizeof(ion_file_offset_t), (ion_byte_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
movq %rsp, %r13
cmpq $-0x1, %r12
je 0x90b2
movq (%r15), %rdi
movq %r12, %rsi
pushq $0x8
popq %rdx
movq %r13, %rcx
callq 0x9213
testb %al, %al
jne 0x90b4
movq %r15, ... | /iondbproject[P]iondb/src/file/linked_file_bag.c |
b_update | ion_bpp_err_t
b_update(
ion_bpp_handle_t handle,
void *key,
ion_bpp_external_address_t rec
) {
int rc; /* return code */
ion_bpp_key_t *mkey; /* match key */
int cc; /* condition code */
ion_bpp_buffer_t *buf, *root;
ion_bpp_buffer_t *tmp[4];
int height; /* height of tree */
ion_bpp_h_n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, 0x18(%rsp)
movq %rdi, %r14
leaq 0x20(%rdi), %r12
movq 0x38(%rdi), %rax
movzwl (%rax), %eax
shrl %eax
imull $0x3, 0xb8(%rdi), %ecx
cmpl %eax, %ecx
jne 0xa4b2
movq %r14, %rdi
callq 0x9d6e
movq 0x38(%r14), %rdx
ad... | /iondbproject[P]iondb/src/dictionary/bpp_tree/bpp_tree.c |
b_find_last_key | ion_bpp_err_t
b_find_last_key(
ion_bpp_handle_t handle,
void *key,
ion_bpp_external_address_t *rec
) {
ion_bpp_err_t rc; /* return code */
ion_bpp_buffer_t *buf; /* buffer */
ion_bpp_h_node_t *h = handle;
buf = &h->root;
while (!leaf(buf)) {
if ((rc = readDisk(handle, childGE(lkey(buf)), &buf)... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq 0x8(%rsp), %r13
movq 0x18(%r13), %rax
movzwl (%rax), %ecx
testb $0x1, %cl
jne 0xaa7c
shrl %ecx
decq %rcx
movslq 0xbc(%rbx), %rdx
imulq... | /iondbproject[P]iondb/src/dictionary/bpp_tree/bpp_tree.c |
lest::run(std::vector<lest::test, std::allocator<lest::test>> const&, int, char**, std::ostream&) | inline int run( tests const & specification, int argc, char ** argv, std::ostream & os = std::cout )
{
return run( specification, make_texts( argv + 1, argv + argc ), os );
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x18(%rsp), %rdi
callq 0x3542
movslq %ebp, %rax
leaq (%r14,%rax,8), %rdx
addq $0x8, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x359c
movaps (%rsp), %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
mov... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::run(std::vector<lest::test, std::allocator<lest::test>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::ostream&) | inline int run( tests specification, texts arguments, std::ostream & os = std::cout )
{
try
{
options option; texts in;
tie( option, in ) = split_arguments( arguments );
if ( option.lexical ) { sort( specification ); }
if ( option.random ) { shuffle( specification, o... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdx, %rbx
movq %rdi, %r14
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x20(%rsp)
andq $0x0, 0x18(%rsp)
andq $0x0, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
leaq 0x1b0(%rsp),... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::ptags& lest::for_test<lest::ptags>(std::vector<lest::test, std::allocator<lest::test>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, lest::ptags&, int) | Action & for_test( tests specification, texts in, Action & perform, int n = 1 )
{
for ( int i = 0; indefinite( n ) || i < n; ++i )
{
for ( tests::iterator pos = specification.begin(); pos != specification.end() ; ++pos )
{
test & testing = *pos;
if ( select( testing.name... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r13
xorl %edx, %edx
leaq 0x30(%rsp), %rbx
leaq 0x18(%rsp), %rbp
movl 0x8(%rsp), %ecx
cmpl $-0x1, %ecx
sete %al
cmpl %ecx, %edx
setl %cl
orb %al, %cl
cmpb $0x1, %cl
jn... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::times::times(std::ostream&, lest::options) | times( std::ostream & out, options option )
: action( out ), output( out, option ), selected( 0 ), failures( 0 ), total()
{
os << std::setfill(' ') << std::fixed << std::setprecision( lest_FEATURE_TIME_PRECISION );
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rsi, 0x8(%rdi)
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x10(%rdi)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rdi)
leaq 0x38(%rdi), %rax
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xm... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::times::~times() | ~times()
{
os << "Elapsed time: " << std::setprecision(1) << total.elapsed_seconds() << " s\n";
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x43ee(%rip), %rsi # 0x8913
callq 0x21d0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rax
movq $0x1, 0x8(%r14,%rax)
leaq 0x68(%rbx), %rdi
callq 0x71fc
movq %r14, %rdi
callq 0x2300
leaq 0x43cd(%rip), %rsi # 0x8922
movq %rax, %rdi
c... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::confirm::~confirm() | ~confirm()
{
if ( failures > 0 )
{
os << failures << " out of " << selected << " selected " << pluralise("test", selected) << " " << colourise( "failed.\n" );
}
else if ( output.pass() )
{
os << "All " << selected << " selected " << pluralise("test", s... | pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %rbx
movl 0x64(%rdi), %esi
testl %esi, %esi
jle 0x4728
movq (%rbx), %rdi
callq 0x2350
leaq 0x4277(%rip), %rsi # 0x892c
movq %rax, %rdi
callq 0x21d0
movl 0x60(%rbx), %esi
movq %rax, %rdi
callq 0x2350
leaq 0x422c(%rip), %rsi # 0x88fb
mo... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::seed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline seed_t seed( text opt, text arg )
{
// std::time_t: implementation dependent
if ( arg == "time" )
return static_cast<seed_t>( time( lest_nullptr ) );
if ( is_number( arg ) )
return static_cast<seed_t>( lest::stoi( arg ) );
throw std::runtime_error( "expecting 'time' or positive... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x36a1(%rip), %rsi # 0x828c
movq %r14, %rdi
callq 0x4bae
testb %al, %al
je 0x4c0b
xorl %edi, %edi
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %r... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::hidden(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline bool hidden( text name )
{
#if lest_FEATURE_REGEX_SEARCH
texts skipped; skipped.push_back( "\\[\\.\\]" ); skipped.push_back( "\\[hide\\]" );
#else
texts skipped; skipped.push_back( "[." ); skipped.push_back( "[hide]" );
#endif
return match( skipped, name );
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x2493(%rip), %rsi # 0x88f1
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x20a0
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x662e
leaq 0x28(%rsp), %rdi
callq 0x20d0
leaq 0x2467(%rip), %rsi ... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::match(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline bool match( texts whats, text line )
{
for ( texts::iterator what = whats.begin(); what != whats.end() ; ++what )
{
if ( search( *what, line ) )
return true;
}
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rax, %r13
movq 0x8(%r14), %rbx
cmpq %rbx, %rax
je 0x65f4
movq %r15, %rdi
movq %r13, %rsi
callq 0x2280
movq %r12, %rdi
movq (%rsp), %rsi
... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::ptags::operator()(lest::test) | ptags & operator()( test testing )
{
texts tags_( tags( testing.name ) );
for ( texts::iterator pos = tags_.begin(); pos != tags_.end() ; ++pos )
result.insert( *pos );
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x2280
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
callq 0x6b90
leaq 0x80(... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::times::operator()(lest::test) | times & operator()( test testing )
{
timer t;
try
{
testing.behaviour( output( testing.name ) );
}
catch( message const & )
{
++failures;
}
os << std::setw(5) << ( 1000 * t.elapsed_seconds() ) << " ms: " << testing.name << "\... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x70ca
movq %rax, (%rsp)
movq 0x20(%r14), %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2280
leaq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x71d2
movq %rax, %rdi
callq *%r15
leaq 0x8(%rsp), %rdi
callq 0x20d0
movq (%... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
f(int) | void f( int n )
{
for (int cnt = 0; cnt < 4; ++cnt)
{
// acquire lock:
while ( lock.test_and_set(nonstd::memory_order_acquire) )
{
// spin read: only until a cmpxchg might succeed:
// while( *p )
_mm_pause();
}
std::cout << "Output from thread " << n << '\n';
// release lock:
lock.clear(nonst... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
xorl %r12d, %r12d
movq 0x5467(%rip), %r14 # 0xcfd0
leaq 0xdf8(%rip), %r15 # 0x8968
pushq $0xa
popq %rbp
cmpl $0x4, %r12d
je 0x7bb4
movb $0x1, %al
xchgb %al, 0x56b0(%rip) # 0xd231
testb %al, %al
je 0x7b89
pause
jmp 0x7b79
movq %r14, ... | /martinmoene[P]atomic-lite/test/atomic.t.cpp |
(anonymous namespace)::PrintUsage(std::ostream*) | void PrintUsage(std::ostream* stream) {
// clang-format off
*stream << std::endl;
*stream << " x2x - data type transformation" << std::endl;
*stream << std::endl;
*stream << " usage:" << std::endl;
*stream << " x2x [ options ] [ infile ] > stdout" << std::endl;
*stream << " options:" << std::endl;... | subq $0x308, %rsp # imm = 0x308
movq %rdi, 0x300(%rsp)
movq 0x300(%rsp), %rdi
movq 0xa343a(%rip), %rsi # 0xaef88
movq %rsi, 0x98(%rsp)
callq 0xa2e0
movq 0x300(%rsp), %rdi
leaq 0x8b177(%rip), %rsi # 0x96ce1
callq 0xa2a0
movq 0x98(%rsp), %rsi
movq %rax, %rdi
callq 0xa2e0
movq 0x98(%rsp), %rsi
movq 0x30... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<signed char, long double>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, long double, long double) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x68, %rsp
movl %r9d, %eax
movl %ecx, (%rsp)
movl %edx, 0x4(%rsp)
movq %rsi, %r9
movl (%rsp), %esi
movq %rdi, %r10
movl 0x4(%rsp), %edi
movb %al, %dl
fldt 0x90(%rsp)
fldt 0x80(%rsp)
movb 0x78(%rsp), %al
movb 0x70(%rsp), %cl
movq %r10, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movl %edi, 0x54(%rsp)
movl %esi, 0x50(%rsp)
mov... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<short, unsigned int>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, unsigned int, unsigned int) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movl 0x68(%rsp), %eax
movl 0x60(%rsp), %eax
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %e... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<sptk::int24_t, double>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, double, double) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x58, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movb 0x68(%rsp), %al
movb 0x60(%rsp), %cl
movq %r10, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
andb $0... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<int, short>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, short, short) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movw 0x68(%rsp), %ax
movw 0x60(%rsp), %ax
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %esi... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<int, sptk::int24_t>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, sptk::int24_t, sptk::int24_t) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x58, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0x68(%rsp), %al
movb 0x60(%rsp), %cl
movq %r10, 0x50(%rsp)
movq %... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<int, unsigned char>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, unsigned char, unsigned char) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movb 0x68(%rsp), %al
movb 0x60(%rsp), %al
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %esi... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<unsigned char, sptk::uint24_t>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, sptk::uint24_t, sptk::uint24_t) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x58, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0x68(%rsp), %al
movb 0x60(%rsp), %cl
movq %r10, 0x50(%rsp)
movq %... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<unsigned char, float>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, float, float) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, (%rsp)
movl %edx, 0x4(%rsp)
movq %rsi, %r9
movl (%rsp), %esi
movq %rdi, %r10
movl 0x4(%rsp), %edi
movb %al, %dl
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
andb $0x1, %d... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<unsigned char, double>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, double, double) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x58, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movb 0x68(%rsp), %al
movb 0x60(%rsp), %cl
movq %r10, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
andb $0... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<sptk::uint24_t, unsigned int>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, unsigned int, unsigned int) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movl 0x68(%rsp), %eax
movl 0x60(%rsp), %eax
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %e... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<sptk::uint24_t, double>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, double, double) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x58, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movb 0x68(%rsp), %al
movb 0x60(%rsp), %cl
movq %r10, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
andb $0... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<unsigned int, long>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, long, long) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %e... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<unsigned int, unsigned long>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, unsigned long, unsigned long) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %e... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<unsigned int, double>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, double, double) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x58, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movb 0x68(%rsp), %al
movb 0x60(%rsp), %cl
movq %r10, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
andb $0... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<unsigned long, long>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, long, long) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %e... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<unsigned long, unsigned short>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, unsigned short, unsigned short) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movw 0x68(%rsp), %ax
movw 0x60(%rsp), %ax
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %esi... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<float, unsigned char>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, unsigned char, unsigned char) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movb 0x68(%rsp), %al
movb 0x60(%rsp), %al
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %esi... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<float, sptk::uint24_t>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, sptk::uint24_t, sptk::uint24_t) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x58, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0x68(%rsp), %al
movb 0x60(%rsp), %cl
movq %r10, 0x50(%rsp)
movq %... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<float, unsigned long>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, unsigned long, unsigned long) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %e... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<double, sptk::uint24_t>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, sptk::uint24_t, sptk::uint24_t) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x58, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0x68(%rsp), %al
movb 0x60(%rsp), %cl
movq %r10, 0x50(%rsp)
movq %... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<double, unsigned long>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, unsigned long, unsigned long) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %e... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<long double, signed char>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, signed char, signed char) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movb 0x68(%rsp), %al
movb 0x60(%rsp), %al
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %esi... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<long double, long>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, long, long) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %e... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<long double, unsigned int>::DataTransform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, (anonymous namespace)::NumericType, (anonymous namespace)::WarningType, bool, bool, bool, unsigned int, unsigned int) | DataTransform(const std::string& print_format, int num_column,
NumericType input_numeric_type, WarningType warning_type,
bool rounding, bool is_ascii_input, bool is_ascii_output,
T2 minimum_value = static_cast<T2>(0),
T2 maximum_value = static_cast<T2>(0))... | subq $0x48, %rsp
movl %r9d, %eax
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r9
movl 0x8(%rsp), %esi
movq %rdi, %r10
movl 0xc(%rsp), %edi
movb %al, %dl
movl 0x68(%rsp), %eax
movl 0x60(%rsp), %eax
movb 0x58(%rsp), %al
movb 0x50(%rsp), %cl
movq %r10, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movl %e... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<signed char, int>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x2c8, %rsp # imm = 0x2C8
movq %rdi, 0x2b8(%rsp)
movq %rsi, 0x2b0(%rsp)
movq 0x2b8(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x22c(%rsp)
movq 0x30(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x2b4fd
leaq 0x208(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xa3b0
movq 0x28(%rsp), %rsi
movq 0x2b0(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<signed char, long>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, 0x2d8(%rsp)
movq %rsi, 0x2d0(%rsp)
movq 0x2d8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x24c(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x2bbcd
leaq 0x228(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xa3b0
movq 0x30(%rsp), %rsi
movq 0x2d0(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<signed char, unsigned long>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, 0x2d8(%rsp)
movq %rsi, 0x2d0(%rsp)
movq 0x2d8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x24c(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x2e13d
leaq 0x228(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xa3b0
movq 0x30(%rsp), %rsi
movq 0x2d0(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<short, sptk::int24_t>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x318, %rsp # imm = 0x318
movq %rdi, 0x308(%rsp)
movq %rsi, 0x300(%rsp)
movq 0x308(%rsp), %rax
movq %rax, 0x70(%rsp)
movl $0x0, 0x27c(%rsp)
movq 0x70(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x30d05
leaq 0x258(%rsp), %rdi
movq %rdi, 0x68(%rsp)
callq 0xa3b0
movq 0x68(%rsp), %rsi
movq 0x300(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<short, long>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, 0x2d8(%rsp)
movq %rsi, 0x2d0(%rsp)
movq 0x2d8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x24c(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x31d4f
leaq 0x228(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xa3b0
movq 0x30(%rsp), %rsi
movq 0x2d0(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<short, float>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x2c8, %rsp # imm = 0x2C8
movq %rdi, 0x2b8(%rsp)
movq %rsi, 0x2b0(%rsp)
movq 0x2b8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x22c(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x349cf
leaq 0x208(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xa3b0
movq 0x30(%rsp), %rsi
movq 0x2b0(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<short, long double>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x328, %rsp # imm = 0x328
movq %rdi, 0x318(%rsp)
movq %rsi, 0x310(%rsp)
movq 0x318(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0x28c(%rsp)
movq 0x40(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x35845
leaq 0x268(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xa3b0
movq 0x38(%rsp), %rsi
movq 0x310(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<long, double>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, 0x2d8(%rsp)
movq %rsi, 0x2d0(%rsp)
movq 0x2d8(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x24c(%rsp)
movq 0x30(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x48c4f
leaq 0x220(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xa3b0
movq 0x28(%rsp), %rsi
movq 0x2d0(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<sptk::uint24_t, sptk::int24_t>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x338, %rsp # imm = 0x338
movq %rdi, 0x328(%rsp)
movq %rsi, 0x320(%rsp)
movq 0x328(%rsp), %rax
movq %rax, 0x88(%rsp)
movl $0x0, 0x29c(%rsp)
leaq 0x299(%rsp), %rdi
callq 0x7d170
movq 0x88(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x56d0e
leaq 0x278(%rsp), %rdi
movq %rdi, 0x80(%rsp)
callq 0xa3b0
movq 0x80(%r... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<unsigned long, unsigned char>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, 0x2d8(%rsp)
movq %rsi, 0x2d0(%rsp)
movq 0x2d8(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x24c(%rsp)
movq 0x30(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x656e1
leaq 0x220(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xa3b0
movq 0x28(%rsp), %rsi
movq 0x2d0(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<float, signed char>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x2c8, %rsp # imm = 0x2C8
movq %rdi, 0x2b8(%rsp)
movq %rsi, 0x2b0(%rsp)
movq 0x2b8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x22c(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x69836
leaq 0x208(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xa3b0
movq 0x30(%rsp), %rsi
movq 0x2b0(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<double, long>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, 0x2d8(%rsp)
movq %rsi, 0x2d0(%rsp)
movq 0x2d8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x24c(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x71806
leaq 0x220(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xa3b0
movq 0x30(%rsp), %rsi
movq 0x2d0(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<double, unsigned long>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, 0x2d8(%rsp)
movq %rsi, 0x2d0(%rsp)
movq 0x2d8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x24c(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x73d06
leaq 0x220(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xa3b0
movq 0x30(%rsp), %rsi
movq 0x2d0(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<long double, signed char>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x318, %rsp # imm = 0x318
movq %rdi, 0x308(%rsp)
movq %rsi, 0x300(%rsp)
movq 0x308(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x27c(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x75b0a
leaq 0x240(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xa3b0
movq 0x30(%rsp), %rsi
movq 0x300(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
(anonymous namespace)::DataTransform<long double, unsigned long>::Run(std::istream*) const | bool Run(std::istream* input_stream) const override {
char buffer[kBufferSize];
int index(0);
for (;; ++index) {
// Read.
T1 input_data;
if (is_ascii_input_) {
std::string word;
*input_stream >> word;
if (word.empty()) break;
try {
input_data = sta... | subq $0x348, %rsp # imm = 0x348
movq %rdi, 0x338(%rsp)
movq %rsi, 0x330(%rsp)
movq 0x338(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x2ac(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, 0x35(%rax)
je 0x7a6fa
leaq 0x270(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xa3b0
movq 0x30(%rsp), %rsi
movq 0x330(%rsp), %rdi
call... | /sp-nitech[P]SPTK/src/main/x2x.cc |
sptk::WriteStream(sptk::Matrix const&, std::ostream*) | bool WriteStream(const sptk::Matrix& matrix_to_write,
std::ostream* output_stream) {
if (0 == matrix_to_write.GetNumRow() || 0 == matrix_to_write.GetNumColumn() ||
NULL == output_stream) {
return false;
}
output_stream->write(reinterpret_cast<const char*>(&(matrix_to_write[0][0])),
... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x85e80
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x7e2ab
movq 0x28(%rsp), %rdi
callq 0x85e90
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x7e2ab
xorl %eax, %eax
cmpq 0x20(%rsp), %rax
jne 0x7e2b2
movb $0x0, 0x37(%rs... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::ConvertStringToDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double*) | bool ConvertStringToDouble(const std::string& input, double* output) {
if (input.empty() || NULL == output) {
return false;
}
char* end;
double converted_value(std::strtod(input.c_str(), &end));
if (0 == input.compare(end) || '\0' != *end || ERANGE == errno) {
return false;
}
*output = converte... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xa470
testb $0x1, %al
jne 0x7e7f5
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
jne 0x7e7fc
movb $0x0, 0x27(%rsp)
jmp 0x7e868
movq 0x18(%rsp), %rdi
callq 0xa130
movq %rax, %rdi
leaq 0x8(%rsp), %rsi
callq 0xa200
movsd %xmm0, (%rsp)
movq 0x... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<long>(long*, std::istream*) | bool ReadStream(T* data_to_read, std::istream* input_stream) {
if (NULL == data_to_read || NULL == input_stream || input_stream->eof()) {
return false;
}
const int type_byte(sizeof(*data_to_read));
input_stream->read(reinterpret_cast<char*>(data_to_read), type_byte);
return (type_byte == input_stream->g... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
je 0x800e7
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
je 0x800e7
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0xa4f0
testb $0x1, %al
jne 0x800e7
jmp 0x800ee
movb $0x0, 0x27(%rsp)
jmp 0x8014c
movl $0x8, ... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<sptk::int24_t>(int, int, std::vector<sptk::int24_t, std::allocator<sptk::int24_t>> const&, std::ostream*, int*) | bool WriteStream(int write_point, int write_size,
const std::vector<T>& sequence_to_write,
std::ostream* output_stream, int* actual_write_size) {
if (write_point < 0 || write_size <= 0 || NULL == output_stream) {
return false;
}
const int end(write_point + write_size);
if ... | subq $0x68, %rsp
movl %edi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
cmpl $0x0, 0x60(%rsp)
jl 0x84872
cmpl $0x0, 0x5c(%rsp)
jle 0x84872
xorl %eax, %eax
cmpq 0x48(%rsp), %rax
jne 0x8487c
movb $0x0, 0x67(%rsp)
jmp 0x8497e
movl 0x60(%rsp), %eax
addl 0x5c(%rsp), %eax... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::Matrix::Matrix(int, int) | Matrix::Matrix(int num_row, int num_column)
: num_row_(num_row < 0 ? 0 : num_row),
num_column_(num_column < 0 ? 0 : num_column) {
data_.resize(num_row_ * num_column_);
index_.resize(num_row_);
for (int i(0); i < num_row_; ++i) {
index_[i] = &data_[i * num_column_];
}
} | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl %edx, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x1f14e(%rip), %rcx # 0xaed10
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, 0x40(%rsp)
cmpl $0x0, 0x5c(%rsp)
jge 0x8fbe1
xorl %eax, %eax
movl %eax, 0x34(%rsp)
jmp 0x8fb... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::Matrix(sptk::Matrix const&) | Matrix::Matrix(const Matrix& matrix)
: num_row_(matrix.num_row_),
num_column_(matrix.num_column_),
data_(matrix.data_),
index_(num_row_) {
for (int i(0); i < num_row_; ++i) {
index_[i] = &data_[i * num_column_];
}
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x1ee61(%rip), %rax # 0xaed20
movq %rax, (%rdi)
movq 0x48(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq 0x48(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rdi)
addq $0x10, %rdi
movq %rdi, 0x... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::SymmetricMatrix::SymmetricMatrix(int) | SymmetricMatrix::SymmetricMatrix(int num_dimension)
: num_dimension_(num_dimension < 0 ? 0 : num_dimension) {
data_.resize(num_dimension_ * (num_dimension_ + 1) / 2);
index_.resize(num_dimension_);
for (int i(0), j(0); i < num_dimension_; ++i, j += i) {
index_[i] = &data_[j];
}
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x1bd42(%rip), %rcx # 0xaed40
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x4c(%rsp)
jge 0x9301d
xorl %eax, %eax
movl %eax, 0x1c(%rsp)
jmp 0x93025
movl 0x4c(%rsp), %e... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
sptk::SymmetricMatrix::operator=(sptk::SymmetricMatrix const&) | SymmetricMatrix& SymmetricMatrix::operator=(const SymmetricMatrix& matrix) {
if (this != &matrix) {
num_dimension_ = matrix.num_dimension_;
data_ = matrix.data_;
index_.resize(num_dimension_);
for (int i(0), j(0); i < num_dimension_; ++i, j += i) {
index_[i] = &data_[j];
}
}
return *thi... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq 0x18(%rsp), %rax
je 0x93324
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq 0x18(%rsp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x912a0
movq 0x8(%rsp), %rax
movq %r... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
setStickyKeys | static void setStickyKeys(_GLFWwindow* window, int enabled)
{
if (window->stickyKeys == enabled)
return;
if (!enabled)
{
int i;
// Release all sticky keys
for (i = 0; i <= GLFW_KEY_LAST; i++)
{
if (window->keys[i] == _GLFW_STICK)
window... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x40(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x9f7a
jmp 0x9fca
cmpl $0x0, -0xc(%rbp)
jne 0x9fbe
movl $0x0, -0x10(%rbp)
cmpl $0x15c, -0x10(%rbp) # imm = 0x15C
jg 0x9fbc
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
mov... | /creationix[P]lit-glfw/glfw/src/input.c |
glfwDefaultWindowHints | void glfwDefaultWindowHints(void)
{
_GLFW_REQUIRE_INIT();
memset(&_glfw.hints, 0, sizeof(_glfw.hints));
// The default is OpenGL with minimum version 1.0
_glfw.hints.api = GLFW_OPENGL_API;
_glfw.hints.major = 1;
_glfw.hints.minor = 0;
// The default is a focused, visible, resizable wind... | pushq %rbp
movq %rsp, %rbp
leaq 0x1113d(%rip), %rax # 0x1d608
cmpb $0x0, (%rax)
jne 0xc4e5
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x9490
jmp 0xc5d7
leaq 0x1112c(%rip), %rdi # 0x1d618
xorl %esi, %esi
movl $0x78, %edx
callq 0x7330
leaq 0x11119(%rip), %rax... | /creationix[P]lit-glfw/glfw/src/window.c |
hasUsableInputMethodStyle | static GLboolean hasUsableInputMethodStyle(void)
{
unsigned int i;
GLboolean found = GL_FALSE;
XIMStyles* styles = NULL;
if (XGetIMValues(_glfw.x11.im, XNQueryInputStyle, &styles, NULL) != NULL)
return GL_FALSE;
for (i = 0; i < styles->count_styles; i++)
{
if (styles->support... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0xf31d(%rip), %rax # 0x1d618
movq 0xe0(%rax), %rdi
leaq 0x9868(%rip), %rsi # 0x17b71
leaq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x7190
cmpq $0x0, %rax
je 0xe324
movb $0x0, -0x1(%rbp)
... | /creationix[P]lit-glfw/glfw/src/x11_init.c |
glfwPlatformGetMonitorPos | void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_g... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xccad(%rip), %rax # 0x1d618
movzbl 0x410(%rax), %eax
cmpl $0x0, %eax
je 0x10a14
leaq 0xcc96(%rip), %rax # 0x1d618
cmpb $0x0, 0x425(%rax)
jne 0x10a14
leaq 0xcc82(%rip), %rax # 0x1d618
movq... | /creationix[P]lit-glfw/glfw/src/x11_monitor.c |
glfwPlatformSetGammaRamp | void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
{
XRRCrtcGamma* gamma = XRRAllocGamma(ramp->size);
memcpy(gamma->red, ramp->red, ramp->size * sizeof(unsigned short));
memcpy(gamma->green, r... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xc861(%rip), %rax # 0x1d618
movzbl 0x410(%rax), %eax
cmpl $0x0, %eax
je 0x10e7a
leaq 0xc84a(%rip), %rax # 0x1d618
cmpb $0x0, 0x424(%rax)
jne 0x10e7a
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x7110
movq %ra... | /creationix[P]lit-glfw/glfw/src/x11_monitor.c |
glfwPlatformDestroyWindow | void _glfwPlatformDestroyWindow(_GLFWwindow* window)
{
if (window->monitor)
leaveFullscreenMode(window);
if (window->x11.ic)
{
XDestroyIC(window->x11.ic);
window->x11.ic = NULL;
}
_glfwDestroyContext(window);
if (window->x11.handle)
{
if (XGetSelectionOwner... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x11e20
movq -0x8(%rbp), %rdi
callq 0x11f70
movq -0x8(%rbp), %rax
cmpq $0x0, 0x278(%rax)
je 0x11e4d
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rdi
callq 0x7560
movq -0x8(%rbp), %rax
movq $0x0, 0x278(%rax)
movq... | /creationix[P]lit-glfw/glfw/src/x11_window.c |
pushSelectionToManager | static void pushSelectionToManager(_GLFWwindow* window)
{
XConvertSelection(_glfw.x11.display,
_glfw.x11.CLIPBOARD_MANAGER,
_glfw.x11.SAVE_TARGETS,
None,
window->x11.handle,
CurrentTime);
for (;;)
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb552(%rip), %rax # 0x1d618
movq 0xb8(%rax), %rdi
leaq 0xb544(%rip), %rax # 0x1d618
movq 0x3d8(%rax), %rsi
leaq 0xb536(%rip), %rax # 0x1d618
movq 0x3e0(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x270(%rax), %r8
xorl %eax, %eax
movl %eax... | /creationix[P]lit-glfw/glfw/src/x11_window.c |
glfwPlatformExtensionSupported | int _glfwPlatformExtensionSupported(const char* extension)
{
const GLubyte* extensions;
// Get list of GLX extensions
extensions = (const GLubyte*) glXQueryExtensionsString(_glfw.x11.display,
_glfw.x11.screen);
if (extensions != NULL)
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x78e5(%rip), %rax # 0x1d618
movq 0xb8(%rax), %rdi
leaq 0x78d7(%rip), %rax # 0x1d618
movl 0xc0(%rax), %esi
callq 0x7780
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15d74
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9290
cm... | /creationix[P]lit-glfw/glfw/src/glx_context.c |
bool (anonymous namespace)::AArch64Operand::isTypedVectorList<((anonymous namespace)::RegKind)1, 4u, 0u, 8u, 1u>() const | bool isTypedVectorList() const {
if (Kind != k_VectorList)
return false;
if (VectorList.Count != NumRegs)
return false;
if (VectorList.RegisterKind != VectorKind)
return false;
if (VectorList.ElementWidth != ElementWidth)
return false;
if (VectorList.Stride != Stride)
r... | xorl %eax, %eax
cmpl $0x8, 0x30(%rdi)
jne 0x7ee071
cmpl $0x4, 0x4c(%rdi)
jne 0x7ee071
cmpl $0x1, 0x5c(%rdi)
jne 0x7ee071
cmpl $0x8, 0x58(%rdi)
jne 0x7ee071
cmpl $0x1, 0x50(%rdi)
jne 0x7ee071
cmpl $0x0, 0x54(%rdi)
sete %al
retq
| /Target/AArch64/AsmParser/AArch64AsmParser.cpp |
bool (anonymous namespace)::AArch64Operand::isTypedVectorList<((anonymous namespace)::RegKind)1, 4u, 0u, 32u, 1u>() const | bool isTypedVectorList() const {
if (Kind != k_VectorList)
return false;
if (VectorList.Count != NumRegs)
return false;
if (VectorList.RegisterKind != VectorKind)
return false;
if (VectorList.ElementWidth != ElementWidth)
return false;
if (VectorList.Stride != Stride)
r... | xorl %eax, %eax
cmpl $0x8, 0x30(%rdi)
jne 0x7ee0e9
cmpl $0x4, 0x4c(%rdi)
jne 0x7ee0e9
cmpl $0x1, 0x5c(%rdi)
jne 0x7ee0e9
cmpl $0x20, 0x58(%rdi)
jne 0x7ee0e9
cmpl $0x1, 0x50(%rdi)
jne 0x7ee0e9
cmpl $0x0, 0x54(%rdi)
sete %al
retq
| /Target/AArch64/AsmParser/AArch64AsmParser.cpp |
(anonymous namespace)::ARMOperand::isGPRMem() const | bool isGPRMem() const {
if (Kind != k_Memory)
return false;
if (Memory.BaseRegNum &&
!ARMMCRegisterClasses[ARM::GPRRegClassID].contains(Memory.BaseRegNum))
return false;
if (Memory.OffsetRegNum &&
!ARMMCRegisterClasses[ARM::GPRRegClassID].contains(Memory.OffsetRegNum))
retu... | cmpl $0xb, 0x30(%rdi)
jne 0x82fe3d
movl 0x88(%rdi), %eax
testq %rax, %rax
je 0x82fe05
movl %eax, %ecx
shrl $0x3, %ecx
leaq 0x4f64109(%rip), %rdx # 0x5793ef0
movzwl 0x96(%rdx), %esi
cmpl %esi, %ecx
jae 0x82fe3d
movq 0x88(%rdx), %rdx
movzbl (%rdx,%rcx), %ecx
andl $0x7, %eax
btl %eax, %ecx
jae 0x82fe3d
movl 0x98(%rdi), ... | /Target/ARM/AsmParser/ARMAsmParser.cpp |
llvm::AArch64Subtarget::useSVEForFixedLengthVectors(llvm::EVT) const | bool useSVEForFixedLengthVectors(EVT VT) const {
if (!useSVEForFixedLengthVectors() || !VT.isFixedLengthVector())
return false;
return VT.getFixedSizeInBits() > AArch64::SVEBitsPerBlock ||
!isNeonAvailable();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movb %r14b, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
cmpb $0x0, 0x1a8(%rdi)
je 0x8fe0e9
cmpb $0x1, 0x17e(%rbx)
jne 0x8fe122
cmpb $0x0, 0x19e(%rbx)
je 0x8fe104
cmpl $0x100, 0x2e4(%rbx) # imm = 0x100
jae 0x8fe122
jmp 0x8fe184
cmpb $0x1, 0x196(%rbx)
jne 0x... | /Target/AArch64/AArch64Subtarget.h |
std::pair<llvm::DenseMapIterator<llvm::GlobalValue*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::GlobalValue*, void>, llvm::detail::DenseSetPair<llvm::GlobalValue*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalValue*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::GlobalValue*, void>, l... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x9714ba
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x97147c
xorl %ecx, %ecx
jmp 0x971495
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
... | /llvm/ADT/DenseMap.h |
llvm::AArch64TargetLowering::LowerFCOPYSIGN(llvm::SDValue, llvm::SelectionDAG&) const | SDValue AArch64TargetLowering::LowerFCOPYSIGN(SDValue Op,
SelectionDAG &DAG) const {
if (!Subtarget->isNeonAvailable() &&
!Subtarget->useSVEForFixedLengthVectors())
return SDValue();
EVT VT = Op.getValueType();
EVT IntVT = VT.changeTypeToInteger();
SDLoc ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rcx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq 0x4e0f8(%rdi), %rax
movb 0x17e(%rax), %cl
cmpb $0x1, %cl
jne 0x9dbe57
cmpb $0x0, 0x19e(%rax)
jne 0x9dbeb1
cmpb $0x0, 0x2e1(%rax)
jne 0x9dbe57
cmpb $0x1, 0x2e2... | /Target/AArch64/AArch64ISelLowering.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.