name string | code string | asm string | file string |
|---|---|---|---|
cmd_ln_log_help_r | void
cmd_ln_log_help_r(ps_config_t *cmdln, ps_arg_t const* defn)
{
if (defn == NULL)
return;
E_INFO("Arguments list definition:\n");
if (cmdln == NULL) {
cmdln = cmd_ln_parse_r(NULL, defn, 0, NULL, FALSE);
arg_log_r(cmdln, defn, TRUE, FALSE);
ps_config_free(cmdln);
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x219e9
jmp 0x21a5c
movl $0x1, %edi
leaq 0x5819f(%rip), %rsi # 0x79b94
movl $0x22a, %edx # imm = 0x22A
leaq 0x58365(%rip), %rcx # 0x79d66
movb $0x0, %al
callq 0x23450
cmpq $0x0, -0x8(%r... | /cmusphinx[P]pocketsphinx/src/util/cmd_ln.c |
hash_table_display | void
hash_table_display(hash_table_t * h, int32 showdisplay)
{
hash_entry_t *e;
int i, j;
j = 0;
printf("Hash with chaining representation of the hash table\n");
for (i = 0; i < h->size; i++) {
e = &(h->table[i]);
if (e->key != NULL) {
printf("|key:");
if (s... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x20(%rbp)
leaq 0x5717c(%rip), %rdi # 0x79ef9
movb $0x0, %al
callq 0x7170
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x22edb
movq -0x8(%rbp), %rax
movq (%rax), %rax
m... | /cmusphinx[P]pocketsphinx/src/util/hash_table.c |
hash_table_iter_next | hash_iter_t *
hash_table_iter_next(hash_iter_t *itor)
{
/* If there is an entry, walk down its list. */
if (itor->ent)
itor->ent = itor->ent->next;
/* If we got to the end of the chain, or we had no entry, scan
* forward in the table to find the next non-empty bucket. */
if (itor->ent == NULL) {
w... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2305b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x23123
jmp 0x2306c
movq -0x10(%rbp), %r... | /cmusphinx[P]pocketsphinx/src/util/hash_table.c |
err_set_loglevel_str | const char *
err_set_loglevel_str(char const *lvl)
{
const char *rv = err_level[min_loglevel];
int i;
if (lvl == NULL)
return NULL;
if (!strncmp(lvl, "ERR_", 4))
lvl += 4;
for (i = 0; i < ERR_MAX; ++i) {
if (!strcmp(lvl, err_level[i])) {
min_loglevel = i;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl 0x70f7e(%rip), %eax # 0x94320
movl %eax, %ecx
leaq 0x70f85(%rip), %rax # 0x94330
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x233c4
movq $0x0, -0x8(%rbp)
jmp 0x2343c
movq -0x10(%rbp), %rdi
leaq 0x56bcb(%rip),... | /cmusphinx[P]pocketsphinx/src/util/err.c |
err_msg_system | void
err_msg_system(err_lvl_t lvl, const char *path, long ln, const char *fmt, ...)
{
int local_errno = errno;
char msg[1024];
va_list ap;
if (!err_cb)
return;
if (lvl < min_loglevel)
return;
va_start(ap, fmt);
vsnprintf(msg, sizeof(msg), fmt, ap);
va_end(ap);
... | pushq %rbp
movq %rsp, %rbp
subq $0x5b0, %rsp # imm = 0x5B0
testb %al, %al
je 0x23647
movaps %xmm0, -0x4e0(%rbp)
movaps %xmm1, -0x4d0(%rbp)
movaps %xmm2, -0x4c0(%rbp)
movaps %xmm3, -0x4b0(%rbp)
movaps %xmm4, -0x4a0(%rbp)
movaps %xmm5, -0x490(%rbp)
movaps %xmm6, -0x480(%rbp)
movaps %xmm7, -0x470(%rbp)
movq %r9... | /cmusphinx[P]pocketsphinx/src/util/err.c |
_ckd_malloc__ | void *
__ckd_malloc__(size_t size, const char *caller_file, int caller_line)
{
void *mem;
#if defined(__ADSPBLACKFIN__) && !defined(__linux__)
if ((mem = heap_malloc(heap_lookup(0),size)) == NULL)
if ((mem = heap_malloc(heap_lookup(1),size)) == NULL)
#else
if ((mem = malloc(size)) == NULL)
#endif
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x72e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x23caf
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq 0x56388(%rip), %rdi # 0x7a030
movb $0x0, %al
... | /cmusphinx[P]pocketsphinx/src/util/ckd_alloc.c |
_ckd_calloc_2d__ | void *
__ckd_calloc_2d__(size_t d1, size_t d2, size_t elemsize,
const char *caller_file, int caller_line)
{
char **ref, *mem;
size_t i, offset;
mem =
(char *) __ckd_calloc__(d1 * d2, elemsize, caller_file,
caller_line);
ref =
(char **) _... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
imulq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x23c10
movq %rax, -0x38(%rbp)
movq -0x8(... | /cmusphinx[P]pocketsphinx/src/util/ckd_alloc.c |
ckd_free | void
ckd_free(void *ptr)
{
#if defined(__ADSPBLACKFIN__) && !defined(__linux__)
if (ptr)
heap_free(0,ptr);
#else
free(ptr);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/ckd_alloc.c |
_ckd_calloc_4d__ | void ****
__ckd_calloc_4d__(size_t d1,
size_t d2,
size_t d3,
size_t d4,
size_t elem_size,
char *file,
int line)
{
void *store;
void **tmp1;
void ***tmp2;
void ****out;
size_t i, j;
store = calloc(d1 * d2 * d3 * d4, elem_size);
if (store == NULL) {
E_FATAL("ckd_callo... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
imulq -0x10(%rbp), %rdi
imulq -0x18(%rbp), %rdi
imulq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
ca... | /cmusphinx[P]pocketsphinx/src/util/ckd_alloc.c |
glist_insert_int32 | gnode_t *
glist_insert_int32(gnode_t * gn, int32 val)
{
gnode_t *newgn;
newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
newgn->data.i = val;
newgn->next = gn->next;
gn->next = newgn;
return newgn;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
movl $0x10, %esi
leaq 0x5444b(%rip), %rdx # 0x7a5eb
movl $0xcd, %ecx
callq 0x23c10
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rc... | /cmusphinx[P]pocketsphinx/src/util/glist.c |
glist_insert_float32 | gnode_t *
glist_insert_float32(gnode_t * gn, float32 val)
{
gnode_t *newgn;
newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
newgn->data.fl = (double)val;
newgn->next = gn->next;
gn->next = newgn;
return newgn;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl $0x1, %edi
movl $0x10, %esi
leaq 0x54389(%rip), %rdx # 0x7a5eb
movl $0xea, %ecx
callq 0x23c10
movq %rax, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp)... | /cmusphinx[P]pocketsphinx/src/util/glist.c |
gnode_free | gnode_t *
gnode_free(gnode_t * gn, gnode_t * pred)
{
gnode_t *next;
next = gn->next;
if (pred) {
assert(pred->next == gn);
pred->next = next;
}
ckd_free((char *) gn);
return next;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2637e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x26353
jmp 0x26372
leaq 0x542ed(%rip), %rdi # 0x7a647
le... | /cmusphinx[P]pocketsphinx/src/util/glist.c |
listelem_add_block | static void
listelem_add_block(listelem_alloc_t *list, char *caller_file, int caller_line)
{
char **cpp, *cp;
size_t j;
int32 blocksize;
blocksize = list->blocksize ? gnode_int32(list->blocksize) : MIN_ALLOC;
/* Check if block size should be increased (if many requests for this size) */
if (lis... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2650f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x2651a
movl $0x32, %eax
movq %rax, -0x40(%rbp)
jmp 0x2651a
movq... | /cmusphinx[P]pocketsphinx/src/util/listelem_alloc.c |
listelem_stats | void
listelem_stats(listelem_alloc_t *list)
{
gnode_t *gn, *gn2;
char **cpp;
size_t n;
E_INFO("Linklist stats:\n");
for (n = 0, cpp = list->freelist; cpp;
cpp = (char **) (*cpp), n++);
E_INFO
("elemsize %lu, #alloc %lu, #freed %lu, #freelist %lu\n",
(unsigned long)list... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
leaq 0x53c7a(%rip), %rsi # 0x7a682
movl $0x119, %edx # imm = 0x119
leaq 0x53da1(%rip), %rcx # 0x7a7b5
movb $0x0, %al
callq 0x23450
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cm... | /cmusphinx[P]pocketsphinx/src/util/listelem_alloc.c |
fclose_comp | void
fclose_comp(FILE * fp, int32 ispipe)
{
if (ispipe) {
#ifdef HAVE_POPEN
#if defined(_WIN32) && (!defined(__SYMBIAN32__))
_pclose(fp);
#else
pclose(fp);
#endif
#endif
}
else
fclose(fp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x26fa0
movq -0x8(%rbp), %rdi
callq 0x7180
jmp 0x26fa9
movq -0x8(%rbp), %rdi
callq 0x7120
addq $0x10, %rsp
popq %rbp
retq
nop
| /cmusphinx[P]pocketsphinx/src/util/pio.c |
fopen_compchk | FILE *
fopen_compchk(const char *file, int32 * ispipe)
{
#ifndef HAVE_POPEN
*ispipe = 0; /* No popen() on WinCE */
/* And therefore the rest of this function is useless. */
return (fopen_comp(file, "r", ispipe));
#else /* HAVE_POPEN */
int32 isgz;
FILE *fh;
/* First just try to fopen_comp() it ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5b6b3(%rip), %rsi # 0x82682
callq 0x26b30
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x26feb
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27249
movq -0x10(%rbp), %rdi
m... | /cmusphinx[P]pocketsphinx/src/util/pio.c |
fread_line | char *
fread_line(FILE *stream, size_t *out_len)
{
char *output, *outptr;
char buf[128];
output = outptr = NULL;
while (fgets(buf, sizeof(buf), stream)) {
size_t len = strlen(buf);
/* Append this data to the buffer. */
if (output == NULL) {
output = (char *)ckd_mallo... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x80, %esi
callq 0x7240
cmpq $0x0, %rax
je 0x277c5
leaq -0xa0(%rbp), %rdi
callq 0x7130
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0x18(%rbp)
j... | /cmusphinx[P]pocketsphinx/src/util/pio.c |
stat_retry | int32
stat_retry(const char *file, struct stat * statbuf)
{
int32 i;
for (i = 0; i < STAT_RETRY_COUNT; i++) {
#ifndef HAVE_SYS_STAT_H
FILE *fp;
if ((fp = (FILE *)fopen(file, "r")) != 0) {
fseek(fp, 0, SEEK_END);
statbuf->st_size = ftell(fp);
fclose(fp);
return 0;
}
#else /* HAVE_SYS_STA... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x27956
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x72b0
cmpl $0x0, %eax
jne 0x27918
movl $0x0, -0x4(%rbp)
jmp 0x2795d
cmpl $0x0, -0x1c(%rbp)
jne 0x27941
movq -0x10(%rbp)... | /cmusphinx[P]pocketsphinx/src/util/pio.c |
bit_encode_free | int
bit_encode_free(bit_encode_t *be)
{
if (be == NULL)
return 0;
if (--be->refcount > 0)
return be->refcount;
ckd_free(be);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x27a3c
movl $0x0, -0x4(%rbp)
jmp 0x27a6f
movq -0x10(%rbp), %rcx
movw 0xa(%rcx), %ax
addw $-0x1, %ax
movw %ax, 0xa(%rcx)
cwtl
cmpl $0x0, %eax
jle 0x27a5f
movq -0x10(%rbp), %rax
movswl 0xa(%rax), %eax
movl %eax, -0x4(%rbp)
jmp ... | /cmusphinx[P]pocketsphinx/src/util/pio.c |
acmod_init | acmod_t *
acmod_init(ps_config_t *config, logmath_t *lmath, fe_t *fe, feat_t *fcb)
{
acmod_t *acmod;
acmod = ckd_calloc(1, sizeof(*acmod));
acmod->config = ps_config_retain(config);
acmod->lmath = logmath_retain(lmath);
acmod->state = ACMOD_IDLE;
/* Initialize or retain fe and fcb. */
if (... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1, %edi
movl $0xc8, %esi
leaq 0x52697(%rip), %rdx # 0x7aa00
movl $0xff, %ecx
callq 0x23c10
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13410
movq %rax, %rcx
movq ... | /cmusphinx[P]pocketsphinx/src/acmod.c |
acmod_init_am | static int
acmod_init_am(acmod_t *acmod)
{
char const *mdeffn, *tmatfn, *mllrfn, *hmmdir;
/* Read model definition. */
if ((mdeffn = ps_config_str(acmod->config, "mdef")) == NULL) {
if ((hmmdir = ps_config_str(acmod->config, "hmm")) == NULL)
E_ERROR("Acoustic model definition is not spe... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x4d3d9(%rip), %rsi # 0x758c3
callq 0x13700
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x28566
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x4d353(%rip), %rsi # 0x7585a
callq 0x13700
movq %rax, -0x... | /cmusphinx[P]pocketsphinx/src/acmod.c |
acmod_free | void
acmod_free(acmod_t *acmod)
{
if (acmod == NULL)
return;
feat_free(acmod->fcb);
fe_free(acmod->fe);
ps_config_free(acmod->config);
if (acmod->mfc_buf)
ckd_free_2d((void **)acmod->mfc_buf);
if (acmod->feat_buf)
feat_array_free(acmod->feat_buf);
if (acmod->mfcfh)... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x28898
jmp 0x28a01
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x39d30
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x33dc0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x13430
movq -0x8(%rbp), %rax
cmpq $0x0, 0x70(... | /cmusphinx[P]pocketsphinx/src/acmod.c |
acmod_set_senfh | int
acmod_set_senfh(acmod_t *acmod, FILE *logfh)
{
if (acmod->senfh)
fclose(acmod->senfh);
acmod->senfh = logfh;
if (logfh == NULL)
return 0;
return acmod_write_senfh_header(acmod, logfh);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x28b9e
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x7120
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x28bbd
movl $0x0, -0... | /cmusphinx[P]pocketsphinx/src/acmod.c |
acmod_grow_feat_buf | void
acmod_grow_feat_buf(acmod_t *acmod, int nfr)
{
if (nfr > MAX_N_FRAMES)
E_FATAL("Decoder can not process more than %d frames at once, "
"requested %d\n", MAX_N_FRAMES, nfr);
acmod->feat_buf = feat_array_realloc(acmod->fcb, acmod->feat_buf,
ac... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x7fffffff, -0xc(%rbp) # imm = 0x7FFFFFFF
jle 0x28ced
jmp 0x28cba
movl -0xc(%rbp), %r9d
movl $0x4, %edi
leaq 0x51d36(%rip), %rsi # 0x7aa00
movl $0x181, %edx # imm = 0x181
leaq 0x51e4c(%rip), %rcx # 0x7ab22
m... | /cmusphinx[P]pocketsphinx/src/acmod.c |
acmod_end_utt | int
acmod_end_utt(acmod_t *acmod)
{
int32 nfr = 0;
acmod->state = ACMOD_ENDED;
if (acmod->n_mfc_frame < acmod->n_mfc_alloc) {
int inptr;
/* Where to start writing them (circular buffer) */
inptr = (acmod->mfc_outidx + acmod->n_mfc_frame) % acmod->n_mfc_alloc;
/* nfr is alway... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movb $0x3, 0xa8(%rax)
movq -0x8(%rbp), %rax
movl 0xb4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xb0(%rcx), %eax
jge 0x28f0d
movq -0x8(%rbp), %rax
movl 0xb8(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0xb4(%rcx), %eax
... | /cmusphinx[P]pocketsphinx/src/acmod.c |
acmod_process_full_raw | static int
acmod_process_full_raw(acmod_t *acmod,
int16 const **inout_raw,
size_t *inout_n_samps)
{
int32 nfr, ntail;
mfcc_t **cepptr;
/* Write to logging file if any. */
if (acmod->rawfh)
fwrite(*inout_raw, 2, *inout_n_samps, acmod->rawfh);
/* ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x29495
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rcx
movl $0x2, %esi
callq 0x... | /cmusphinx[P]pocketsphinx/src/acmod.c |
allphone_search_fill_iter | static void
allphone_search_fill_iter(ps_seg_t *seg, phseg_t *phseg)
{
seg->sf = phseg->sf;
seg->ef = phseg->ef;
seg->ascr = phseg->score;
seg->lscr = phseg->tscore;
seg->text = bin_mdef_ciphone_str(ps_search_acmod(seg->search)->mdef, phseg->ci);
seg->wid = BAD_S3WID;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x8(%... | /cmusphinx[P]pocketsphinx/src/allphone_search.c |
ngram_fwdtree_search | int
ngram_fwdtree_search(ngram_search_t *ngs, int frame_idx)
{
int16 const *senscr;
/* Activate our HMMs for the current frame if need be. */
if (!ps_search_acmod(ngs)->compallsen)
compute_sen_active(ngs, frame_idx);
/* Compute GMM scores for the current frame. */
if ((senscr = acmod_score... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpb $0x0, 0xa9(%rax)
jne 0x577fc
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x57940
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x2a970
movq %rax... | /cmusphinx[P]pocketsphinx/src/ngram_search_fwdtree.c |
kws_detections_add | void
kws_detections_add(kws_detections_t *detections, const char* keyphrase, int sf, int ef, int prob, int ascr)
{
gnode_t *gn;
kws_detection_t* detection;
for (gn = detections->detect_list; gn; gn = gnode_next(gn)) {
kws_detection_t *det = (kws_detection_t *)gnode_ptr(gn);
if (strcmp(keyphr... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6c4f5
movq -0x28(%rbp), %rax
movq (%rax), %rax
m... | /cmusphinx[P]pocketsphinx/src/kws_detections.c |
ngram_model_trie_read_dmp | ngram_model_t *
ngram_model_trie_read_dmp(ps_config_t * config,
const char *file_name, logmath_t * lmath)
{
uint8 do_swap;
int32 is_pipe;
int32 k;
uint32 j;
int32 vn, ts;
int32 count;
uint32 counts[3];
uint32 *unigram_next;
int order;
char str[1024];
... | pushq %rbp
movq %rsp, %rbp
subq $0x4a0, %rsp # imm = 0x4A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, %edi
leaq 0x15451(%rip), %rsi # 0x82e04
movl $0x1cf, %edx # imm = 0x1CF
leaq 0x15672(%rip), %rcx # 0x83031
movb $0x0, %al
callq 0x23450
movq -0x18(%rbp... | /cmusphinx[P]pocketsphinx/src/lm/ngram_model_trie.c |
ngram_model_trie_raw_score | static int32
ngram_model_trie_raw_score(ngram_model_t * base, int32 wid, int32 * hist,
int32 n_hist, int32 * n_used)
{
int32 i;
ngram_model_trie_t *model = (ngram_model_trie_t *) base;
if (n_hist > model->base.n - 1)
n_hist = model->base.n - 1;
for (i = 0; i < n_hist;... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movq -0x38(%rbp), %rcx
movzbl 0x18(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x6e412
movq ... | /cmusphinx[P]pocketsphinx/src/lm/ngram_model_trie.c |
middle_init | void
middle_init(middle_t * middle, void *base_mem, uint8 quant_bits,
uint32 entries, uint32 max_vocab, uint32 max_next,
void *next_source)
{
middle->quant_bits = quant_bits;
bitarr_mask_from_max(&middle->next_mask, max_next);
middle->next_source = next_source;
if (entries + 1 >=... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq 0x10(%rbp), %rdx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x20(%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
... | /cmusphinx[P]pocketsphinx/src/lm/lm_trie.c |
lm_trie_read_ug | static size_t
lm_trie_read_ug(lm_trie_t * trie, uint32 * counts, FILE * fp)
{
size_t rv = fread(trie->unigrams, sizeof(*trie->unigrams),
(counts[0] + 1), fp);
if (SWAP_LM_TRIE) {
int i;
for (i = 0; (uint32)i < counts[0] + 1; ++i) {
SWAP_FLOAT32(&trie->unigrams[i... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movq -0x18(%rbp), %rcx
movl $0xc, %esi
callq 0x70f0
movq %rax, -0x20(%rbp)
... | /cmusphinx[P]pocketsphinx/src/lm/lm_trie.c |
lm_trie_build | void
lm_trie_build(lm_trie_t * trie, ngram_raw_t ** raw_ngrams, uint32 * counts, uint32 *out_counts,
int order)
{
int i;
lm_trie_fix_counts(raw_ngrams, counts, out_counts, order);
lm_trie_alloc_ngram(trie, out_counts, order);
if (order > 1)
E_INFO("Training quantizer\n");
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x6f9c0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(... | /cmusphinx[P]pocketsphinx/src/lm/lm_trie.c |
middle_finish_loading | static void
middle_finish_loading(middle_t * middle, uint32 next_end)
{
bitarr_address_t address;
address.base = middle->base.base;
address.offset =
(middle->base.insert_index + 1) * middle->base.total_bits -
middle->next_mask.bits;
bitarr_write_int25(address, middle->next_mask.bits, nex... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
imull %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x18(%rcx), %ec... | /cmusphinx[P]pocketsphinx/src/lm/lm_trie.c |
unigram_next | static uint32
unigram_next(lm_trie_t * trie, int order)
{
return order ==
2 ? trie->longest->base.insert_index : trie->middle_begin->base.
insert_index;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x71541
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x7154f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
po... | /cmusphinx[P]pocketsphinx/src/lm/lm_trie.c |
longest_insert | static bitarr_address_t
longest_insert(longest_t * longest, uint32 index)
{
bitarr_address_t address;
assert(index <= longest->base.word_mask);
address.base = longest->base.base;
address.offset = longest->base.insert_index * longest->base.total_bits;
bitarr_write_int25(address, longest->base.word_bi... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
ja 0x7167d
jmp 0x7169c
leaq 0x12259(%rip), %rdi # 0x838dd
leaq 0x11ed0(%rip), %rsi # 0x8355b
movl $0x99, %edx
leaq 0x12267(%rip), %rcx # 0x838fe
callq ... | /cmusphinx[P]pocketsphinx/src/lm/lm_trie.c |
gauden_dist | int32
gauden_dist(gauden_t * g,
int mgau, int32 n_top, mfcc_t** obs, gauden_dist_t ** out_dist)
{
int32 f;
assert((n_top > 0) && (n_top <= g->n_density));
for (f = 0; f < g->n_feat; f++) {
compute_dist(out_dist[f], n_top,
obs[f], g->featlen[f],
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x72cae
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jg 0x72cae
jmp 0x72ccd
leaq 0x10e00(%rip), %rdi # 0x83ab5
... | /cmusphinx[P]pocketsphinx/src/ms_gauden.c |
enlarge_ntuple_list(ntuple_list_s*) | void enlarge_ntuple_list(ntuple_list n_tuple)
{
/* check parameters */
if ( n_tuple == NULL || n_tuple->values == NULL || n_tuple->max_size == 0 )
error("enlarge_ntuple_list: invalid n-tuple.");
/* duplicate number of tuples */
n_tuple->max_size *= 2;
/* realloc memory */
n_tuple->valu... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6698
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6698
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x66a4
leaq 0x7ae6(%rip), %rdi # 0xe185
callq 0x6580
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
shll %ecx
movl %ecx,... | /soumyadeep94[P]Line-Segment-Detector-using-OpenCV/Detection/lsd.cpp |
new_image_char(unsigned int, unsigned int) | image_char new_image_char(unsigned int xsize, unsigned int ysize)
{
image_char image;
/* check parameters */
if ( xsize == 0 || ysize == 0 ) error("new_image_char: invalid image size.");
/* get memory */
image = (image_char) malloc( sizeof(struct image_char_s) );
if ( image == NULL ) error("no... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x68ba
cmpl $0x0, -0x8(%rbp)
jne 0x68c6
leaq 0x795e(%rip), %rdi # 0xe21f
callq 0x6580
movl $0x10, %edi
callq 0x61c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x68e7
leaq 0x7890(%rip), %rdi ... | /soumyadeep94[P]Line-Segment-Detector-using-OpenCV/Detection/lsd.cpp |
new_image_char_ini(unsigned int, unsigned int, unsigned char) | image_char new_image_char_ini( unsigned int xsize, unsigned int ysize,
unsigned char fill_value )
{
image_char image = new_image_char(xsize, ysize); /* create image */
unsigned int N = xsize * ysize;
unsigned int i;
/* check parameters */
if ( image == NULL || image->... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x68a0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x697d
movq -0x18(%rbp)... | /soumyadeep94[P]Line-Segment-Detector-using-OpenCV/Detection/lsd.cpp |
mbedtls_aes_setkey_dec | int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits )
{
int i, j, ret;
mbedtls_aes_context cty;
uint32_t *RK;
uint32_t *SK;
mbedtls_aes_init( &cty );
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
if( aes_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movl $0x120, %edx # imm = 0x120
movq %r12, %rdi
xorl %esi, %esi
callq 0x30c0
leaq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
movq %r12, ... | /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aes_encrypt | void mbedtls_aes_encrypt( mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16] )
{
int i;
uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
RK = ctx->rk;
GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
GET_UINT32_LE( X1, inp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x8(%rsp)
movq 0x8(%rdi), %rax
movl (%rax), %ecx
movl 0x4(%rax), %r8d
xorl (%rsi), %ecx
xorl 0x4(%rsi), %r8d
movl 0x8(%rax), %r9d
xorl 0x8(%rsi), %r9d
movl 0xc(%rax), %edx
addq $0x10, %rax
xorl 0xc(%rsi), %edx
movl (%rdi), %esi
sarl %esi
leaq... | /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aes_decrypt | void mbedtls_aes_decrypt( mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16] )
{
int i;
uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
RK = ctx->rk;
GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
GET_UINT32_LE( X1, inp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x8(%rsp)
movq 0x8(%rdi), %rax
movl (%rax), %ecx
movl 0x4(%rax), %edx
xorl (%rsi), %ecx
xorl 0x4(%rsi), %edx
movl 0x8(%rax), %r9d
xorl 0x8(%rsi), %r9d
movl 0xc(%rax), %r10d
addq $0x10, %rax
xorl 0xc(%rsi), %r10d
movl (%rdi), %esi
sarl %esi
le... | /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_sha1 | void mbedtls_sha1( const unsigned char *input, size_t ilen, unsigned char output[20] )
{
mbedtls_sha1_context ctx;
mbedtls_sha1_init( &ctx );
mbedtls_sha1_starts( &ctx );
mbedtls_sha1_update( &ctx, input, ilen );
mbedtls_sha1_finish( &ctx, output );
mbedtls_sha1_free( &ctx );
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movups %xmm0, 0x4c(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps 0x34bd(%rip), %xmm0 # 0xc6c0
movups %xmm0... | /Dragonchang[P]https_client/mbedtls/library/sha1.c |
mbedtls_sha256_process | void mbedtls_sha256_process( mbedtls_sha256_context *ctx, const unsigned char data[64] )
{
uint32_t temp1, temp2, W[64];
uint32_t A[8];
unsigned int i;
for( i = 0; i < 8; i++ )
A[i] = ctx->state[i];
#if defined(MBEDTLS_SHA256_SMALLER)
for( i = 0; i < 64; i++ )
{
if( i < 16 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x8(%rdi), %rax
movq %rax, -0x48(%rsp)
movdqu 0x8(%rdi), %xmm0
movups 0x18(%rdi), %xmm1
movaps %xmm1, -0x60(%rsp)
movdqa %xmm0, -0x70(%rsp)
xorl %eax, %eax
movl (%rsi,%rax,4), %ecx
bswapl %ecx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax... | /Dragonchang[P]https_client/mbedtls/library/sha256.c |
mbedtls_sha256 | void mbedtls_sha256( const unsigned char *input, size_t ilen,
unsigned char output[32], int is224 )
{
mbedtls_sha256_context ctx;
mbedtls_sha256_init( &ctx );
mbedtls_sha256_starts( &ctx, is224 );
mbedtls_sha256_update( &ctx, input, ilen );
mbedtls_sha256_finish( &ctx, output );
mb... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x60(%rsp)
testl %ecx, %ecx
je 0xa0ee
movaps 0x295d(%rip)... | /Dragonchang[P]https_client/mbedtls/library/sha256.c |
mbedtls_sha512_update | void mbedtls_sha512_update( mbedtls_sha512_context *ctx, const unsigned char *input,
size_t ilen )
{
size_t fill;
unsigned int left;
if( ilen == 0 )
return;
left = (unsigned int) (ctx->total[0] & 0x7F);
fill = 128 - left;
ctx->total[0] += (uint64_t) ilen;
if( ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0xa967
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rcx
movl %ecx, %eax
andl $0x7f, %eax
movq %rcx, %rsi
addq %rdx, %rsi
movq %rsi, (%rdi)
jae 0xa8de
incq 0x8(%r14)
testl %eax, %eax
je 0xa91d
movl $0x80, %r15d
subl %eax, %r15d
movq %rdx, %r13
s... | /Dragonchang[P]https_client/mbedtls/library/sha512.c |
mbedtls_sha512 | void mbedtls_sha512( const unsigned char *input, size_t ilen,
unsigned char output[64], int is384 )
{
mbedtls_sha512_context ctx;
mbedtls_sha512_init( &ctx );
mbedtls_sha512_starts( &ctx, is384 );
mbedtls_sha512_update( &ctx, input, ilen );
mbedtls_sha512_finish( &ctx, output );
mb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movl $0xd8, %edx
xorl %esi, %esi
callq 0x30c0
testl %ebp, %ebp
je 0xac77
movaps 0x2140(%rip), %xmm0 # 0xcda0
movaps 0x2149(%rip), %xmm1 # 0xcdb0
movaps 0x2... | /Dragonchang[P]https_client/mbedtls/library/sha512.c |
mbedtls_md5_starts | void mbedtls_md5_starts( mbedtls_md5_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
} | movaps 0x174d(%rip), %xmm0 # 0xc6b0
movups %xmm0, (%rdi)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%rdi)
retq
| /Dragonchang[P]https_client/mbedtls/library/md5.c |
mbedtls_md5 | void mbedtls_md5( const unsigned char *input, size_t ilen, unsigned char output[16] )
{
mbedtls_md5_context ctx;
mbedtls_md5_init( &ctx );
mbedtls_md5_starts( &ctx );
mbedtls_md5_update( &ctx, input, ilen );
mbedtls_md5_finish( &ctx, output );
mbedtls_md5_free( &ctx );
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movq $0x0, 0x50(%r14)
movaps 0xd9d(%rip), %xmm0 # 0xc6c0
movups %xmm0, 0... | /Dragonchang[P]https_client/mbedtls/library/md5.c |
lshift | static Bigint *
lshift(Bigint *b, int k MTd)
{
int i, k1, n, n1;
Bigint *b1;
ULong *x, *x1, *xe, z;
#ifdef Pack_32
n = k >> 5;
#else
n = k >> 4;
#endif
k1 = b->k;
n1 = n + b->wds + 1;
for(i = b->maxwds; n1 > i; i <<= 1)
k1++;
b1 = Balloc(k1 MTa);
x1 = b1->x;
for(i = 0; i < n; i++)
*x1++ = 0;
x = b->x;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r12d
sarl $0x5, %r12d
movl 0x8(%rdi), %edi
movl 0xc(%rbx), %eax
movl 0x14(%rbx), %r15d
addl %r12d, %r15d
cmpl %eax, %r15d
jl 0x5b73
incl %edi
addl %eax, %eax
jmp 0x5b68
callq 0x5775
movq %rax, %r14
leaq 0x18(%rax), %rdi
t... | /DevSolar[P]pdclib/functions/_dtoa/dtoa.c |
PDCLIB_freedtoa | void
_PDCLIB_freedtoa(char *s)
{
#ifdef MULTIPLE_THREADS
ThInfo *TI = 0;
#endif
Bigint *b = (Bigint *)((int *)s - 1);
b->maxwds = 1 << (b->k = *(int*)b);
Bfree(b MTb);
#ifndef MULTIPLE_THREADS
if (s == dtoa_result)
dtoa_result = 0;
#endif
} | pushq %rbx
movq %rdi, %rbx
movslq -0x4(%rdi), %rcx
movl $0x1, %eax
shll %cl, %eax
addq $-0x4, %rdi
movl %ecx, 0x4(%rbx)
movl %eax, 0x8(%rbx)
cmpq $0x8, %rcx
jl 0x61d2
callq 0x9692
jmp 0x61e4
leaq 0x10af7(%rip), %rax # 0x16cd0
movq (%rax,%rcx,8), %rdx
movq %rdx, (%rdi)
movq %rdi, (%rax,%rcx,8)
cmpq %rbx, 0x10ad5(%ri... | /DevSolar[P]pdclib/functions/_dtoa/dtoa.c |
hi0bits | static int
hi0bits(ULong x)
{
int k = 0;
if (!(x & 0xffff0000)) {
k = 16;
x <<= 16;
}
if (!(x & 0xff000000)) {
k += 8;
x <<= 8;
}
if (!(x & 0xf0000000)) {
k += 4;
x <<= 4;
}
if (!(x & 0xc0000000)) {
k += 2;
x <<= 2;
}
if (!(x & 0x80000000)) {
k++;
if (!(x & 0x40000000))
return 32;
... | movl %edi, %eax
shll $0x10, %eax
xorl %ecx, %ecx
cmpl $0x10000, %edi # imm = 0x10000
setb %cl
cmovael %edi, %eax
shll $0x4, %ecx
movl %eax, %edx
shll $0x8, %edx
cmpl $0x1000000, %eax # imm = 0x1000000
cmovael %eax, %edx
leal 0x8(%rcx), %eax
cmovael %ecx, %eax
movl %edx, %ecx
shll $0x4, %ecx
cmpl $0x1000... | /DevSolar[P]pdclib/functions/_dtoa/dtoa.c |
rshift | static void
rshift(Bigint *b, int k)
{
ULong *x, *x1, *xe, y;
int n;
x = x1 = b->x;
n = k >> kshift;
if (n < b->wds) {
xe = x + b->wds;
x += n;
if (k &= kmask) {
n = 32 - k;
y = *x++ >> k;
while(x < xe) {
*x1++ = (y | (*x << n)) & 0xffffffff;
y = *x++ >> k;
}
if ((*x1 = y) !=0)
x... | pushq %rbp
pushq %rbx
leaq 0x18(%rdi), %rdx
movl %esi, %r9d
shrl $0x5, %r9d
movl 0x14(%rdi), %r10d
movq %rdx, %rcx
cmpl %r10d, %r9d
jge 0x7b7a
leaq (%rdx,%r10,4), %r8
movl %r9d, %eax
andl $0x1f, %esi
je 0x7b3e
leaq (%rdx,%rax,4), %r9
movl (%r9), %r11d
addq $0x4, %r9
movl %esi, %ecx
shrl %cl, %r11d
cmpq %r8, %r9
jae 0x7... | /DevSolar[P]pdclib/functions/_dtoa/dtoa.c |
increment | static Bigint *
increment(Bigint *b MTd)
{
ULong *x, *xe;
Bigint *b1;
x = b->x;
xe = x + b->wds;
do {
if (*x < (ULong)0xffffffffL) {
++*x;
return b;
}
*x++ = 0;
} while(x < xe);
{
if (b->wds >= b->maxwds) {
b1 = Balloc(b->k+1 MTa);
Bcopy(b1,b);
Bfree(b MTa);
b = b1;
}
b->x[b->wd... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movslq 0x14(%rdi), %rcx
leaq (%rdi,%rcx,4), %rcx
addq $0x18, %rcx
movl (%rax), %edx
cmpl $-0x1, %edx
jne 0x7c8d
movl $0x0, (%rax)
addq $0x4, %rax
cmpq %rcx, %rax
jb 0x7c6a
movl 0x14(%rbx), %eax
cmpl 0xc(%rbx), %eax
jge 0x7c93
movq %rbx, %r14
jmp 0x7... | /DevSolar[P]pdclib/functions/_dtoa/dtoa.c |
ialloc | static void** ialloc(mstate m,
size_t n_elements,
size_t* sizes,
int opts,
void* chunks[]) {
size_t element_size; /* chunksize of each element, if all same */
size_t contents_size; /* total size of elements */
size_t ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0xc9a2(%rip) # 0x17620
jne 0xac85
callq 0x95d8
testq %rbx, %rbx
je 0xac97
testq %r15, %r15
je 0xae9b
xorl %edi, %edi
jmp 0xacc3
testq %r15, %r15
je 0xad26
le... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
PDCLIB_print | const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status )
{
const char * orig_spec = spec;
if ( *( ++spec ) == '%' )
{
/* %% -> print single '%' */
PUT( *spec );
return ++spec;
}
/* Initializing status structure */
status->flags = 0;
status->... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rdi), %rax
movq %rax, 0x18(%rsp)
movb 0x1(%rdi), %al
cmpb $0x25, %al
jne 0xbe5b
movq 0x10(%rbx), %rcx
cmpq 0x8(%rbx), %rcx
jae 0xbf8b
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0xbf84
movl $0x25, %edi
callq 0xd14c
jmp ... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print.c |
fputs | int fputs( const char * _PDCLIB_restrict s, struct _PDCLIB_file_t * _PDCLIB_restrict stream )
{
_PDCLIB_LOCK( stream->mtx );
if ( _PDCLIB_prepwrite( stream ) == EOF )
{
_PDCLIB_UNLOCK( stream->mtx );
return EOF;
}
while ( *s != '\0' )
{
/* Unbuffered and line buffered s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x48(%rsi), %rbx
movq %rbx, %rdi
callq 0xd08c
movq %r14, %rdi
callq 0xbdc4
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0xd90f
movb (%r15), %al
testb %al, %al
je 0xd8f9
incq %r15
movq 0x8(%r14), %rcx
movq ... | /DevSolar[P]pdclib/functions/stdio/fputs.c |
PDCLIB_getstream | int _PDCLIB_getstream( struct _PDCLIB_file_t * stream )
{
struct _PDCLIB_file_t * previous;
if ( ! _PDCLIB_isstream( stream, &previous ) )
{
*_PDCLIB_errno_func() = _PDCLIB_EBADF;
return EOF;
}
if ( previous != NULL )
{
previous->next = stream->next;
}
else
... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0xd98c
testl %eax, %eax
je 0xd966
movq 0x8(%rsp), %rcx
movq 0x78(%rbx), %rax
testq %rcx, %rcx
je 0xd978
movq %rax, 0x78(%rcx)
jmp 0xd982
callq 0xbdbc
movl $0x9, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0xd984
leaq 0x8759(%rip), %rc... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_getstream.c |
lest::passing::passing(lest::location, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) | passing( location where_, text expr_, text decomposition_, bool zen )
: success( "passed", where_, expr_ + (zen ? "":" for " + decomposition_) ) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x70f1(%rip), %rsi # 0xc155
leaq 0x70f0(%rip), %rdx # 0xc15b
leaq 0x20(%rsp), %rdi
callq 0x496e
l... | /martinmoene[P]lest/include/lest/lest.hpp |
lest::env::context[abi:cxx11]() | text context() { return testing + sections(); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x5a80
movq 0x20(%r14), %rcx
movq 0x28(%r14), %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3220
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rc... | /martinmoene[P]lest/include/lest/lest.hpp |
lest::inform(lest::location, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline void inform( location where, text expr )
{
try
{
throw;
}
catch( message const & )
{
throw;
}
catch( std::exception const & e )
{
throw unexpected{ where, expr, with_message( e.what() ) }; \
}
catch(...)
{
throw unexpected{ where, expr, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r14
movq %rdi, %r15
callq 0x32a0
jmp 0x5538
movq %rdx, %r13
movq %rax, %rdi
cmpl $0x3, %r13d
jne 0x5341
callq 0x30f0
callq 0x32a0
jmp 0x5538
callq 0x30f0
movq %rax, %r12
movl $0x78, %edi
callq 0x3110... | /martinmoene[P]lest/include/lest/lest.hpp |
lest::success::success(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, lest::location, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | success( text kind_, location where_, text expr_, text note_ = "" )
: message( kind_, where_, expr_, note_ ) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x5648
leaq 0x70(%rsp), %rbp
m... | /martinmoene[P]lest/include/lest/lest.hpp |
lest::unexpected::unexpected(lest::location, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | unexpected( location where_, text expr_, text note_ = "" )
: message{ "failed: got unexpected exception", where_, expr_, note_ } {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x659d(%rip), %rsi # 0xc170
leaq 0x65b6(%rip), %rdx # 0xc190
leaq 0x40(%rsp), %rdi
callq 0x496e
leaq 0x70(%rsp), ... | /martinmoene[P]lest/include/lest/lest.hpp |
lest::expected::expected(lest::location, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | expected( location where_, text expr_, text excpt_ = "" )
: message{ "failed: didn't get exception", where_, expr_, excpt_ } {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x6468(%rip), %rsi # 0xc1b5
leaq 0x647d(%rip), %rdx # 0xc1d1
leaq 0x40(%rsp), %rdi
callq 0x496e
leaq 0x70(%rsp), ... | /martinmoene[P]lest/include/lest/lest.hpp |
lest::split_arguments(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>>>>) | inline auto split_arguments( texts args ) -> std::tuple<options, texts>
{
options option; texts in;
bool in_options = true;
for ( auto & arg : args )
{
if ( in_options )
{
text opt, val;
std::tie( opt, val ) = split_option( arg );
if ( opt[0] !... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0xb0(%rsp)
movq $0x0, 0xc0(%rsp)
movq (%rsi), %r14
movq 0x8(%rsi), %r15
cmpq %r15, %r14
je 0x6d57
movq %rbx, 0xd0(%rsp)
leaq 0x1a8(%rsp), %rbp
movl $0x1, 0xc(%rsp... | /martinmoene[P]lest/include/lest/lest.hpp |
lest::times&& lest::for_test<lest::times>(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::times&&, int) | Action && for_test( tests specification, texts in, Action && perform, int n = 1 )
{
for ( int i = 0; indefinite( n ) || i < n; ++i )
{
for ( auto & testing : specification )
{
if ( select( testing.name, in ) )
if ( abort( perform( testing ) ) )
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
cmpl $-0x1, %ecx
setne %al
movl %ecx, 0x8(%rsp)
testl %ecx, %ecx
setle %cl
testb %cl, %al
jne 0x7add
xorl %edx, %edx
leaq 0x30(%rsp), %rbx
leaq 0x90(%rsp), %r15
leaq 0x50(... | /martinmoene[P]lest/include/lest/lest.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), %r14
leaq 0x4cbf(%rip), %rsi # 0xc8e8
movl $0xe, %edx
movq %r14, %rdi
callq 0x3230
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x1, 0x8(%r14,%rax)
callq 0x3050
subq 0x68(%rbx), %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %... | /martinmoene[P]lest/include/lest/lest.hpp |
lpo::program_options<int, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::has_opt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool
has_opt(const std::string & name, const std::string & short_name) const
{
return std::any_of(std::cbegin(m_check_list), std::cend(m_check_list), [&](const auto & n) {
return (name == n.first || (!short_name.empty() && short_name == n.second));
});
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x58(%rdi), %r14
addq $0x48, %rbx
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
cmpq %rbx, %r14
je 0xf659
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf66a
testb %al, %al
jne 0xf659
movq %r14, %rdi
callq 0x3280
movq %rax, %r14
cmpq %rbx, %rax
jn... | /kenavolic[P]boost_light/lpo.h |
parse_tags | static int parse_tags(y4m_input *y4m_ctx, FILE *file) {
char tag[256];
char end; // Character denoting the end of the tag, ' ' or '\n'.
// Set Y4M tags to defaults, updating them as processing occurs. Mandatory
// fields are marked with -1 and will be checked after the tags are parsed.
y4m_ctx->pic_w = -1;
... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x118(%rsp)
movq %rsi, 0x110(%rsp)
movq 0x118(%rsp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movq 0x118(%rsp), %rax
movl $0xffffffff, 0x4(%rax) # imm = 0xFFFFFFFF
movq 0x118(%rsp), %rax
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
movq 0x118(%rsp), ... | /m-ab-s[P]aom/common/y4minput.c |
y4m_convert_42xpaldv_42xjpeg | static void y4m_convert_42xpaldv_42xjpeg(y4m_input *_y4m, unsigned char *_dst,
unsigned char *_aux) {
unsigned char *tmp;
int c_w;
int c_h;
int c_sz;
int pli;
int y;
int x;
/*Skip past the luma data.*/
_dst += _y4m->pic_w * _y4m->pic_h;
/*Compute the size of ... | subq $0x388, %rsp # imm = 0x388
movq %rdi, 0x380(%rsp)
movq %rsi, 0x378(%rsp)
movq %rdx, 0x370(%rsp)
movq 0x380(%rsp), %rax
movl (%rax), %ecx
movq 0x380(%rsp), %rax
imull 0x4(%rax), %ecx
movq 0x378(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x378(%rsp)
movq 0x380(%rsp), %rax
movl (%rax), %eax
a... | /m-ab-s[P]aom/common/y4minput.c |
I420ToAR30Matrix | LIBYUV_API
int I420ToAR30Matrix(const uint8_t* src_y,
int src_stride_y,
const uint8_t* src_u,
int src_stride_u,
const uint8_t* src_v,
int src_stride_v,
uint8_t* dst_ar30,
in... | subq $0x48, %rsp
movl 0x70(%rsp), %eax
movl 0x68(%rsp), %eax
movq 0x60(%rsp), %rax
movl 0x58(%rsp), %eax
movq 0x50(%rsp), %rax
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movl %r9d, 0x14(%rsp)
leaq 0x19c23(%rip), %rax # 0x547c0
movq %rax, 0x8(%rsp)
cm... | /m-ab-s[P]aom/third_party/libyuv/source/convert_argb.cc |
YUY2ToNV12 | LIBYUV_API
int YUY2ToNV12(const uint8_t* src_yuy2,
int src_stride_yuy2,
uint8_t* dst_y,
int dst_stride_y,
uint8_t* dst_uv,
int dst_stride_uv,
int width,
int height) {
int y;
int halfwidth = (width + 1) >> 1;
v... | subq $0x68, %rsp
movl 0x78(%rsp), %eax
movl 0x70(%rsp), %eax
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq %rdx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movq %r8, 0x38(%rsp)
movl %r9d, 0x34(%rsp)
movl 0x70(%rsp), %eax
addl $0x1, %eax
sarl %eax
movl %eax, 0x2c(%rsp)
leaq 0x14614(%rip), %rax # 0x56630
movq %rax, 0x20(%rs... | /m-ab-s[P]aom/third_party/libyuv/source/planar_functions.cc |
SobelToPlaneRow_C | void SobelToPlaneRow_C(const uint8_t* src_sobelx,
const uint8_t* src_sobely,
uint8_t* dst_y,
int width) {
int i;
for (i = 0; i < width; ++i) {
int r = src_sobelx[i];
int b = src_sobely[i];
int s = clamp255(r + b);
dst_y[i] = (uint8... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x53d0e
movq 0x30(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rc... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
J400ToARGBRow_C | void J400ToARGBRow_C(const uint8_t* src_y, uint8_t* dst_argb, int width) {
// Copy a Y to RGB.
int x;
for (x = 0; x < width; ++x) {
uint8_t y = src_y[0];
dst_argb[2] = dst_argb[1] = dst_argb[0] = y;
dst_argb[3] = 255u;
dst_argb += 4;
++src_y;
}
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x53e58
movq -0x8(%rsp), %rax
movb (%rax), %al
movb %al, -0x19(%rsp)
movb -0x19(%rsp), %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movb %cl, 0x1(%rax)
movq ... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
libyuv::YuvPixel(unsigned char, unsigned char, unsigned char, unsigned char*, unsigned char*, unsigned char*, libyuv::YuvConstants const*) | static __inline void YuvPixel(uint8_t y,
uint8_t u,
uint8_t v,
uint8_t* b,
uint8_t* g,
uint8_t* r,
const struct YuvConstants* yuvconstants) ... | subq $0x48, %rsp
movb %dl, %al
movb %sil, %dl
movb %dil, %sil
movq 0x50(%rsp), %rdi
movb %sil, 0x47(%rsp)
movb %dl, 0x46(%rsp)
movb %al, 0x45(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x50(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rax
movsbl 0x20(%rax), %ea... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I422ToARGBRow_C | void I422ToARGBRow_C(const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
YuvP... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x541aa
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I210ToARGBRow_C | void I210ToARGBRow_C(const uint16_t* src_y,
const uint16_t* src_u,
const uint16_t* src_v,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
Y... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x54338
movq 0x30(%rsp), %rax
movw (%rax), %di
movq 0x28(%rsp), %rax
movw ... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I210ToAR30Row_C | void I210ToAR30Row_C(const uint16_t* src_y,
const uint16_t* src_u,
const uint16_t* src_v,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
int b;
int g;
int r;
for (x = 0; x <... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x54582
movq 0x40(%rsp), %rax
movw (%rax), %di
movq 0x38(%rsp), %rax
m... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
libyuv::StoreAR30(unsigned char*, int, int, int) | static void StoreAR30(uint8_t* rgb_buf, int b, int g, int r) {
uint32_t ar30;
b = b >> 4; // convert 10.6 to 10 bit.
g = g >> 4;
r = r >> 4;
b = Clamp10(b);
g = Clamp10(g);
r = Clamp10(r);
ar30 = b | ((uint32_t)g << 10) | ((uint32_t)r << 20) | 0xc0000000;
(*(uint32_t*)rgb_buf) = ar30;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movl 0xc(%rsp), %eax
sarl $0x4, %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
sarl $0x4, %eax
movl %eax, 0x8(%rsp)
movl 0x4(%rsp), %eax
sarl $0x4, %eax
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %edi
callq 0x5ab20
movl %eax... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I422ToAR30Row_C | void I422ToAR30Row_C(const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
int b;
int g;
int r;
for (x = 0; x < wi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x548f4
movq 0x40(%rsp), %rax
movb (%rax), %dil
movq 0x38(%rsp), %rax
... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I422AlphaToARGBRow_C | void I422AlphaToARGBRow_C(const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
const uint8_t* src_a,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
... | subq $0x48, %rsp
movl 0x50(%rsp), %eax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl 0x50(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x54bc9
movq 0x40(%rsp), %rax
movb (%rax), %dil
m... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I422ToRGB24Row_C | void I422ToRGB24Row_C(const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x54d48
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I422ToARGB1555Row_C | void I422ToARGB1555Row_C(const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* dst_argb1555,
const struct YuvConstants* yuvconstants,
int width) {
uint8_t b0;
uint8_t g0;... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x55170
movq 0x40(%rsp), %rax
movb (%rax), %dil
movq 0x38(%rsp), %rax
... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I422ToRGB565Row_C | void I422ToRGB565Row_C(const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* dst_rgb565,
const struct YuvConstants* yuvconstants,
int width) {
uint8_t b0;
uint8_t g0;
uint8_t r0;... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x553aa
movq 0x40(%rsp), %rax
movb (%rax), %dil
movq 0x38(%rsp), %rax
... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
NV12ToARGBRow_C | void NV12ToARGBRow_C(const uint8_t* src_y,
const uint8_t* src_uv,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
YuvPixel(src_y[0], src_uv[0], src_uv[1], rgb_b... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x55569
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb (%rax), %sil
mov... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
NV21ToARGBRow_C | void NV21ToARGBRow_C(const uint8_t* src_y,
const uint8_t* src_vu,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
YuvPixel(src_y[0], src_vu[1], src_vu[0], rgb_b... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x556e9
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb 0x1(%rax), %sil
... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
NV21ToRGB24Row_C | void NV21ToRGB24Row_C(const uint8_t* src_y,
const uint8_t* src_vu,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
YuvPixel(src_y[0], src_vu[1], src_vu[0], ... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x559b7
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb 0x1(%rax), %sil
... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
MirrorRow_C | void MirrorRow_C(const uint8_t* src, uint8_t* dst, int width) {
int x;
src += width - 1;
for (x = 0; x < width - 1; x += 2) {
dst[x] = src[0];
dst[x + 1] = src[-1];
src -= 2;
}
if (width & 1) {
dst[width - 1] = src[0];
}
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movq -0x8(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x562f5
movq -0x8(%rsp), %rax
... | /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
ARGBToYJRow_AVX2 | void ARGBToYJRow_AVX2(const uint8_t* src_argb, uint8_t* dst_y, int width) {
asm volatile(
"vbroadcastf128 %3,%%ymm4 \n"
"vbroadcastf128 %4,%%ymm5 \n"
"vmovdqu %5,%%ymm6 \n"
LABELALIGN RGBTOY_AVX2(ymm5)
: "+r"(src_argb), /... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rdx
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %eax
vbroadcastf128 0xa2844b(%rip), %ymm4 # ymm4 = mem[0,1,0,1]
vbroadcastf128 0xa28422(%rip), %ymm5 # ymm5 = mem[0,1,0,1]
vmovdqu 0xa2845a(%rip), %ymm6 # 0xa84260
vmovdqu (%rdx), %ymm0
v... | /m-ab-s[P]aom/third_party/libyuv/source/row_gcc.cc |
RGBAToYJRow_AVX2 | void RGBAToYJRow_AVX2(const uint8_t* src_rgba, uint8_t* dst_y, int width) {
asm volatile(
"vbroadcastf128 %3,%%ymm4 \n"
"vbroadcastf128 %4,%%ymm5 \n"
"vmovdqu %5,%%ymm6 \n"
LABELALIGN RGBTOY_AVX2(
ymm5) "vzeroupper ... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rdx
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %eax
vbroadcastf128 0xa2839b(%rip), %ymm4 # ymm4 = mem[0,1,0,1]
vbroadcastf128 0xa28362(%rip), %ymm5 # ymm5 = mem[0,1,0,1]
vmovdqu 0xa2839a(%rip), %ymm6 # 0xa84260
vmovdqu (%rdx), %ymm0
v... | /m-ab-s[P]aom/third_party/libyuv/source/row_gcc.cc |
ARGBToUVRow_SSSE3 | void ARGBToUVRow_SSSE3(const uint8_t* src_argb0,
int src_stride_argb,
uint8_t* dst_u,
uint8_t* dst_v,
int width) {
asm volatile(
"movdqa %5,%%xmm3 \n"
"movdqa %6,%%xmm4 ... | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
movq -0x8(%rsp), %rdx
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %esi
movslq -0xc(%rsp), %rdi
movdqa 0xa282f8(%rip), %xmm3 # 0xa84290
movdqa 0xa28300(%rip), %xmm4 # 0xa842a0
movdqa 0... | /m-ab-s[P]aom/third_party/libyuv/source/row_gcc.cc |
ABGRToUVRow_AVX2 | void ABGRToUVRow_AVX2(const uint8_t* src_abgr0,
int src_stride_abgr,
uint8_t* dst_u,
uint8_t* dst_v,
int width) {
asm volatile(
"vbroadcastf128 %5,%%ymm5 \n"
"vbroadcastf128 %6,%%ymm6 ... | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
movq -0x8(%rsp), %rdx
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %esi
movslq -0xc(%rsp), %rdi
vbroadcastf128 0xa280f7(%rip), %ymm5 # ymm5 = mem[0,1,0,1]
vbroadcastf128 0xa2811e(%rip), %y... | /m-ab-s[P]aom/third_party/libyuv/source/row_gcc.cc |
ARGBToUVJRow_AVX2 | void ARGBToUVJRow_AVX2(const uint8_t* src_argb0,
int src_stride_argb,
uint8_t* dst_u,
uint8_t* dst_v,
int width) {
asm volatile(
"vbroadcastf128 %5,%%ymm5 \n"
"vbroadcastf128 %6,%%ymm6 ... | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
movq -0x8(%rsp), %rdx
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %esi
movslq -0xc(%rsp), %rdi
vbroadcastf128 0xa27f57(%rip), %ymm5 # ymm5 = mem[0,1,0,1]
vbroadcastf128 0xa2802e(%rip), %y... | /m-ab-s[P]aom/third_party/libyuv/source/row_gcc.cc |
ARGBToUVJRow_SSSE3 | void ARGBToUVJRow_SSSE3(const uint8_t* src_argb0,
int src_stride_argb,
uint8_t* dst_u,
uint8_t* dst_v,
int width) {
asm volatile(
"movdqa %5,%%xmm3 \n"
"movdqa %6,%%xmm4 ... | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
movq -0x8(%rsp), %rdx
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %esi
movslq -0xc(%rsp), %rdi
movdqa 0xa27f28(%rip), %xmm3 # 0xa84300
movdqa 0xa27f30(%rip), %xmm4 # 0xa84310
movdqa 0... | /m-ab-s[P]aom/third_party/libyuv/source/row_gcc.cc |
ScaleRowDown2Box_16_C | void ScaleRowDown2Box_16_C(const uint16_t* src_ptr,
ptrdiff_t src_stride,
uint16_t* dst,
int dst_width) {
const uint16_t* s = src_ptr;
const uint16_t* t = src_ptr + src_stride;
int x;
for (x = 0; x < dst_width - 1; x += 2) {
ds... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
movl -0x34(%rsp), %eax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl ... | /m-ab-s[P]aom/third_party/libyuv/source/scale_common.cc |
ScaleRowDown4_C | void ScaleRowDown4_C(const uint8_t* src_ptr,
ptrdiff_t src_stride,
uint8_t* dst,
int dst_width) {
int x;
(void)src_stride;
for (x = 0; x < dst_width - 1; x += 2) {
dst[0] = src_ptr[2];
dst[1] = src_ptr[6];
dst += 2;
src_ptr += 8;
}
... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x67ae2
movq -0x8(%rsp), %rax
movb 0x2(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, (%rax)
movq -0x8(%rsp), %rax
movb 0x6(%ra... | /m-ab-s[P]aom/third_party/libyuv/source/scale_common.cc |
aom_img_add_metadata | int aom_img_add_metadata(aom_image_t *img, uint32_t type, const uint8_t *data,
size_t sz, aom_metadata_insert_flags_t insert_flag) {
if (!img) return -1;
if (!img->metadata) {
img->metadata = aom_img_metadata_array_alloc(0);
if (!img->metadata) return -1;
}
// Some metadata type... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0xa0311
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xa0456
movq 0x38(%rsp), %rax
cmpq $0x0, 0x98(%rax)
jne 0xa0356
xorl %eax, %eax
movl %eax, %edi
callq 0xa01... | /m-ab-s[P]aom/aom/src/aom_image.c |
aom_rb_read_primitive_quniform | static uint16_t aom_rb_read_primitive_quniform(struct aom_read_bit_buffer *rb,
uint16_t n) {
if (n <= 1) return 0;
const int l = get_msb(n) + 1;
const int m = (1 << l) - n;
const int v = aom_rb_read_literal(rb, l - 1);
return v < m ? v : (v << 1) - m + aom_rb_rea... | subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x18(%rsp)
movw %ax, 0x16(%rsp)
movzwl 0x16(%rsp), %eax
cmpl $0x1, %eax
jg 0xa0b14
movw $0x0, 0x26(%rsp)
jmp 0xa0b8f
movzwl 0x16(%rsp), %edi
callq 0xa0ba0
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movzwl 0x16(%rsp), %ecx
subl %ec... | /m-ab-s[P]aom/aom_dsp/bitreader_buffer.c |
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.