name string | code string | asm string | file string |
|---|---|---|---|
mergesort_2way_parallel(unsigned char**, unsigned long, unsigned char**) | static void
mergesort_2way_parallel(unsigned char** strings, size_t n, unsigned char** tmp)
{
if (n < 32) {
insertion_sort(strings, n, 0);
return;
}
const size_t split0 = n/2;
#pragma omp parallel sections
{
#pragma omp section
mergesort_2way_parallel(strings, split0, tmp);
#pragma omp section
merg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x1f, %rsi
ja 0x12542a
cmpq $0x2, %rbx
jl 0x12541b
movq %r14, %rax
movl %ebx, %ecx
leal -0x1(%rcx), %ebx
movq 0x8(%rax), %rdx
addq $0x8, %rax
movq %rax, %rsi
cmpq %r14, %rsi
jbe 0x125413
movq -0x8(%rsi), %... | /rantala[P]string-sorting/src/mergesort.cpp |
void mergesort_losertree_parallel<128u>(unsigned char**, unsigned long, unsigned char**) | static void
mergesort_losertree_parallel(unsigned char** strings, size_t n, unsigned char** tmp)
{
if (n < 0x10000) {
mergesort_4way_parallel(strings, n, tmp);
return;
}
debug() << __func__ << "(), n="<<n<<"\n";
const size_t split = size_t(double(n) / double(K));
std::array<std::pair<unsigned char**, size_t>, ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x820, %rsp # imm = 0x820
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0x134140
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x820, %rsp # imm = 0x820
popq %rbx
popq %r12
popq %r... | /rantala[P]string-sorting/src/mergesort_losertree.cpp |
mergesort_lcp_3way_parallel(unsigned char**, unsigned long) | void
mergesort_lcp_3way_parallel(unsigned char** strings, size_t n)
{
debug() << __func__ << '\n';
lcp_t* lcp_input = (lcp_t*) malloc(n*sizeof(lcp_t));
lcp_t* lcp_tmp = (lcp_t*) malloc(n*sizeof(lcp_t));
unsigned char** input_tmp = (unsigned char**)
malloc(n*sizeof(unsigned char*));
#pragma omp parallel
{
#prag... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa35c8b(%rip), %rsi # 0xb6ac98
movq 0xa35c8c(%rip), %rdx # 0xb6aca0
movq 0x64fd5(%rip), %rdi # 0x199ff0
callq 0x1c350
movq %rax, %r15
leaq 0x340e3(%rip), %rsi # 0x16910d
movl $0x1b, %edx
movq... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
mergesort_cache2_lcp_2way_parallel(unsigned char**, unsigned long) | void mergesort_cache2_lcp_2way_parallel(unsigned char** strings, size_t n)
{ mergesort_cache_lcp_2way_parallel<uint16_t>(strings, n); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq (,%rsi,8), %rbx
movq %rbx, %rdi
callq 0x1c3f0
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
callq 0x1c3f0
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
callq 0x1c3f0
movq %rax, %r13
leaq (%r14,%r14), %r15
movq %r15, ... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
to_str[abi:cxx11](unsigned char) | static std::string to_str(unsigned char c)
{
std::ostringstream strm;
if (isprint(c)) strm << c;
else strm << '<' << int(c) << '>';
return strm.str();
} | pushq %rbp
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1c400
movl %ebp, %edi
callq 0x1c550
leaq 0xf(%rsp), %rsi
testl %eax, %eax
je 0x13d91d
movb %bpl, (%rsi)
leaq 0x10(%rsp), %rdi
movl $0x1, %edx
callq 0x1c350
jmp 0x13d94e
movb $0x3c, (%rsi)
leaq ... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
void merge_lcp_2way_unstable<false>(unsigned char**, unsigned long*, unsigned long, unsigned char**, unsigned long*, unsigned long, unsigned char**, unsigned long*) | static void
merge_lcp_2way_unstable(
unsigned char** from0, lcp_t* restrict lcp_input0, size_t n0,
unsigned char** from1, lcp_t* restrict lcp_input1, size_t n1,
unsigned char** result, lcp_t* restrict lcp_result)
{
debug() << __func__ << "(): n0=" << n0 << ", n1=" << n1 <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r14
movq %r8, 0x20(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r15
movq 0xa2c28f(%rip), %rsi # 0xb6ac98
movq 0xa2c290(%rip), %rdx # 0xb6aca0
movq 0x5b5d9(%rip), %rdi # 0x199ff0
callq 0x1c35... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
MergeResult mergesort_lcp_2way_parallel<false>(unsigned char**, unsigned char**, unsigned long*, unsigned long*, unsigned long) | MergeResult
mergesort_lcp_2way_parallel(
unsigned char** restrict strings_input,
unsigned char** restrict strings_output,
lcp_t* restrict lcp_input, lcp_t* restrict lcp_output,
size_t n)
{
assert(n > 0);
debug() << __func__ << "(): n=" << n << '\n';
if (n < 0x10000)
return mergesort_lcp_2way<true>(
str... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %r8, %r8
je 0x1403cb
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r13
movq 0xa2aa53(%rip), %rsi # 0xb6ac98
movq 0xa2aa54(%rip), %rdx # 0xb6aca0
movq 0x59d9d(%rip), %rdi # 0x199ff0
callq 0x1c3... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
MergeResult mergesort_cache_lcp_2way<true, unsigned char>(unsigned char**, unsigned char**, unsigned long*, unsigned long*, unsigned char*, unsigned char*, unsigned long) | MergeResult
mergesort_cache_lcp_2way(
unsigned char** strings_input, unsigned char** strings_output,
lcp_t* restrict lcp_input, lcp_t* restrict lcp_output,
CharT* restrict cache_input, CharT* restrict cache_output,
size_t n)
{
debug() << __func__ << "(): n=" << n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %rbx
movq %rcx, 0x38(%rsp)
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %r15
movq 0xb0(%rsp), %r13
movq 0xa27eda(%rip), %rsi # 0xb6ac98
movq 0xa27edb(%rip), %rdx # 0xb6aca0
movq 0x57224(%rip), %rdi ... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
MergeResult mergesort_cache_lcp_2way<true, unsigned short>(unsigned char**, unsigned char**, unsigned long*, unsigned long*, unsigned short*, unsigned short*, unsigned long) | MergeResult
mergesort_cache_lcp_2way(
unsigned char** strings_input, unsigned char** strings_output,
lcp_t* restrict lcp_input, lcp_t* restrict lcp_output,
CharT* restrict cache_input, CharT* restrict cache_output,
size_t n)
{
debug() << __func__ << "(): n=" << n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbp
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq 0xa25126(%rip), %rsi # 0xb6ac98
movq 0xa25127(%rip), %rdx # 0xb6aca0
movq 0x54470(%rip), %rdi # 0x199ff0
callq 0x1c350
movq... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
void merge_cache_lcp_2way<true, unsigned int>(unsigned char**, unsigned long*, unsigned int*, unsigned long, unsigned char**, unsigned long*, unsigned int*, unsigned long, unsigned char**, unsigned long*, unsigned int*) | void
merge_cache_lcp_2way(
unsigned char** from0, lcp_t* restrict lcp_input0, CharT* restrict cache_input0, size_t n0,
unsigned char** from1, lcp_t* restrict lcp_input1, CharT* restrict cache_input1, size_t n1,
unsigned char** result, lcp_t* restrict lcp_result, CharT* restrict cache_result)
{
d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, 0x20(%rsp)
movq %r8, %r13
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %rbp
movq 0x158(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0xa2008e(%rip), %rsi # 0xb6ac98
movq 0xa2008f(%rip), %rdx ... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
MergeResult mergesort_cache_lcp_2way_parallel<true, unsigned short>(unsigned char**, unsigned char**, unsigned long*, unsigned long*, unsigned short*, unsigned short*, unsigned long) | MergeResult
mergesort_cache_lcp_2way_parallel(
unsigned char** strings_input, unsigned char** strings_output,
lcp_t* restrict lcp_input, lcp_t* restrict lcp_output,
CharT* restrict cache_input, CharT* restrict cache_output,
size_t n)
{
debug() << __func__ << "():... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbp
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq 0xa1d6a2(%rip), %rsi # 0xb6ac98
movq 0xa1d6a3(%rip), %rdx # 0xb6aca0
movq 0x4c9ec(%rip), %rdi # 0x199ff0
callq 0x1c350
movq... | /rantala[P]string-sorting/src/mergesort_lcp.cpp |
routine_cmp | static int
routine_cmp(const void *a, const void *b)
{
const struct routine *aa = *(const struct routine **)a;
const struct routine *bb = *(const struct routine **)b;
if (aa->f == bb->f)
return 0;
if (aa->multicore < bb->multicore)
return -1;
if (aa->multicore > bb->multicore)
return 1;
return strcmp(aa->na... | movq (%rdi), %rcx
movq (%rsi), %rdx
movq (%rcx), %rax
cmpq (%rdx), %rax
je 0x14ed38
movb 0x18(%rcx), %sil
andb $0x1, %sil
movb 0x18(%rdx), %dil
andb $0x1, %dil
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpb %dil, %sil
jb 0x14ed37
movl $0x1, %eax
jbe 0x14ed3b
retq
xorl %eax, %eax
retq
movq 0x8(%rcx), %rdi
movq 0x8... | /rantala[P]string-sorting/src/routines.c |
status_entry | static char *
status_entry(const char *key)
{
char *result = NULL;
char *line = NULL;
size_t line_n = 0;
FILE *fp;
fp = fopen("/proc/self/status", "r");
if (!fp)
goto done;
while (getline(&line, &line_n, fp) != -1) {
char *v;
v = strchr(line, ':');
if (!v || *v == '\0')
continue;
*v = '\0';
if (st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
xorl %ebx, %ebx
movq %rbx, (%rsp)
movq %rbx, 0x10(%rsp)
leaq 0x1c717(%rip), %rdi # 0x16b6f5
leaq 0x13606(%rip), %rsi # 0x1625eb
callq 0x1c370
movq %rax, %r14
testq %rax, %rax
je 0x14f09e
xorl %ebx, %ebx
movq ... | /rantala[P]string-sorting/src/util/cpus_allowed.c |
mkqsort | void mkqsort(unsigned char **a, int n, int depth)
{ int d, r, partval;
unsigned char **pa, **pb, **pc, **pd, **pl, **pm, **pn, *t;
if (n < 20) {
inssort(a, n, depth);
return;
}
pl = a;
pm = a + (n/2);
pn = a + (n-1);
if (n > 30) { /* On big arrays, pseudomedian of 9 */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r13d
movq %rdi, %r14
movq %rdx, (%rsp)
movslq %edx, %rbx
cmpl $0x13, %r13d
jle 0x15035d
movl %r13d, %eax
shrl %eax
leaq (%r14,%rax,8), %r15
movl %r13d, %eax
leaq (%r14,%rax,8), %r12
addq $-0x8, %r12
cmpl $0x1f, %r13d
jl 0x150... | /rantala[P]string-sorting/external/mkqsort.c |
cradix_rantala | void cradix_rantala(LPPSTR a, UINT n)
{
UINT kbsd, kbsd1, i, j, stage, d, MEMSIZE;
UINT *cptr, gs, count[AS];
LPSTR tj, tk, ax, tl, kb, ss, tt, GrpKB[AS];
LPPSTR GrpKP[AS], ak, ta, tc, t;
if (sizeof(LPPSTR)>sizeof(unsigned char)*BS)
MEMSIZE=sizeof(LPPSTR);
else
MEMSIZE=sizeof(unsigned char)*BS;
/* workspace ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1848, %rsp # imm = 0x1848
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%rsi,8), %rdi
callq 0x1c3f0
movq %rax, %r15
leaq (,%rbx,4), %rdi
callq 0x1c3f0
movq 0x49545(%rip), %rcx # 0x19a320
movq %r14, (%rcx)
movq %rax, 0x28(%rsp)
movq %rax, 0... | /rantala[P]string-sorting/external/cradix-improved.c |
parallel_string_radix_sort::ParallelStringRadixSort<unsigned char const*>::Sort16Parallel(unsigned long, unsigned long, unsigned long, bool) | void ParallelStringRadixSort<StringType>
::Sort16Parallel(size_t bgn, size_t end, size_t depth, bool flip) {
size_t cnt[1 << 16] = {};
StringType *src = (flip ? temp_ : data_) + bgn;
StringType *dst = (flip ? data_ : temp_) + bgn;
uint16_t *let = letters16_ + bgn;
size_t n = end - bgn;
#ifdef _OPENMP
#p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80018, %rsp # imm = 0x80018
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x10(%rsp), %r13
movl $0x80000, %edx # imm = 0x80000
movq %r13, %rdi
xorl %esi, %esi
callq 0x1c180
movq 0x8(%r12), ... | /rantala[P]string-sorting/external/parallel_string_radix_sort.h |
parallel_string_radix_sort::ParallelStringRadixSort<unsigned char const*>::Sort16(unsigned long, unsigned long, unsigned long, bool) | void ParallelStringRadixSort<StringType>
::Sort16(size_t bgn, size_t end, size_t depth, bool flip) {
size_t *cnt = new size_t[1 << 16]();
PSRS_CHECK(cnt != NULL);
StringType *src = (flip ? temp_ : data_) + bgn;
StringType *dst = (flip ? data_ : temp_) + bgn;
uint16_t *let = letters16_ + bgn;
size_t n = end... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r12
movl $0x80000, %edi # imm = 0x80000
callq 0x1c030
movq %rax, %r13
movl $0x80000, %edx # imm = 0x80000
movq %rax, %rdi
xorl %esi, %esi
callq... | /rantala[P]string-sorting/external/parallel_string_radix_sort.h |
(anonymous namespace)::PrintTypeErrorMessage(char const*) | void PrintTypeErrorMessage(const char* option) {
std::ostringstream error_message;
error_message << "The argument for the -" << option
<< " option must be numeric";
sptk::PrintErrorMessage("sopr", error_message);
} | pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x4350
leaq 0x96cd(%rip), %rsi # 0xf262
movl $0x16, %edx
movq %r14, %rdi
callq 0x42f0
testq %rbx, %rbx
je 0x5bc1
movq %rbx, %rdi
callq 0x4130
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movq %rax,... | /sp-nitech[P]SPTK/src/main/sopr.cc |
(anonymous namespace)::PrintUsage(std::ostream*) | void PrintUsage(std::ostream* stream) {
// clang-format off
*stream << std::endl;
*stream << " sopr - perform scalar operations" << std::endl;
*stream << std::endl;
*stream << " usage:" << std::endl;
*stream << " sopr [ options ] [ infile ] > stdout" << std::endl;
*stream << " options:" << std::en... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41e0
leaq 0x94c5(%rip), %rsi # 0xf2ae
movl $0x21, %edx
movq %rbx, %rdi
callq 0x42f0
movq (%rbx), %rax
movq -0x... | /sp-nitech[P]SPTK/src/main/sopr.cc |
sptk::ScalarOperation::~ScalarOperation() | virtual ~ScalarOperation() {
for (std::vector<ScalarOperation::ModuleInterface*>::iterator itr(
modules_.begin());
itr != modules_.end(); ++itr) {
delete (*itr);
}
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0xf6bd(%rip), %rax # 0x16420
movq %rax, (%rdi)
movq 0x10(%rdi), %rbx
movq 0x18(%rdi), %rax
cmpq %rax, %rbx
je 0x6d95
movq %rdi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6d88
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%r14), %rax
addq $0x8, %rbx
cmpq %rax, %rbx
jne 0x6d76... | /sp-nitech[P]SPTK/include/SPTK/math/scalar_operation.h |
ya_getopt_internal(int, char* const*, char const*, option const*, int*, int) | static int ya_getopt_internal(int argc, char * const argv[], const char *optstring, const struct option *longopts, int *longindex, int long_only)
{
static int start, end;
if (ya_optopt == '?') {
ya_optopt = 0;
}
if (posixly_correct == -1) {
check_gnu_extension(optstring);
}
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r10
movq %rcx, %r8
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, 0x14(%rsp)
cmpl $0x3f, 0x103f5(%rip) # 0x17280
jne 0x6e97
movl $0x0, 0x103e9(%rip) # 0x17280
movl 0x103e7(%rip), %esi # 0x17284
movb (%rbx), %r12b
cmpl $... | /sp-nitech[P]SPTK/third_party/GETOPT/ya_getopt.cc |
ya_getopt_longopts(int, char* const*, char*, char const*, option const*, int*, int*) | static int ya_getopt_longopts(int argc, char * const argv[], char *arg, const char *optstring, const struct option *longopts, int *longindex, int *long_only_flag)
{
char *val = NULL;
const struct option *opt;
size_t namelen;
int idx;
for (idx = 0; longopts[idx].name != NULL; idx++) {
opt = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %rcx, (%rsp)
movq %rsi, %r12
movl %edi, 0xc(%rsp)
movq (%r8), %r14
testq %r14, %r14
je 0x727e
movq %r8, %rbx
movq %rdx, %r13
addq $0x20, %rbx
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x4130
movq %rax, %r15
movq %r1... | /sp-nitech[P]SPTK/third_party/GETOPT/ya_getopt.cc |
sptk::ScalarOperation::AddModuloOperation(double) | bool ScalarOperation::AddModuloOperation(double divisor) {
if (0 == divisor) return false;
modules_.push_back(new OperationPerformer(new Modulo(divisor)));
return true;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x78bf
jnp 0x7936
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x10, %edi
callq 0x42c0
leaq 0xecba(%rip), %rcx # 0x165a0
movq %rcx, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
l... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddLowerBoundingOperation(double) | bool ScalarOperation::AddLowerBoundingOperation(double lower_bound) {
modules_.push_back(new OperationPerformer(new LowerBounding(lower_bound)));
return true;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x10, %edi
callq 0x42c0
leaq 0xec02(%rip), %rcx # 0x16620
movq %rcx, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
leaq 0xea6d(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddAbsoluteOperation() | bool ScalarOperation::AddAbsoluteOperation() {
modules_.push_back(new OperationPerformer(new Absolute()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xeb67(%rip), %rcx # 0x166a0
movq %rcx, (%rax)
leaq 0xe95d(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddReciprocalOperation() | bool ScalarOperation::AddReciprocalOperation() {
modules_.push_back(new OperationPerformer(new Reciprocal()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xeb2d(%rip), %rcx # 0x166e0
movq %rcx, (%rax)
leaq 0xe8e3(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddSquareRootOperation() | bool ScalarOperation::AddSquareRootOperation() {
modules_.push_back(new OperationPerformer(new SquareRoot()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xeab9(%rip), %rcx # 0x16760
movq %rcx, (%rax)
leaq 0xe7ef(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddLogarithmOperation(double) | bool ScalarOperation::AddLogarithmOperation(double base) {
if (base <= 0.0) return false;
modules_.push_back(new OperationPerformer(new Logarithm(base)));
return true;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x7e16
movq %rdi, %rbx
movsd %xmm0, (%rsp)
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x10, %edi
callq 0x42c0
movq %rax, %r15
leaq 0xea2a(%rip), %rax # 0x167e0
movq %rax, (%r15)
movsd (%rsp), %xmm0
callq 0x4240
m... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddNaturalExponentialOperation() | bool ScalarOperation::AddNaturalExponentialOperation() {
modules_.push_back(new OperationPerformer(new NaturalExponential()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe9c1(%rip), %rcx # 0x16820
movq %rcx, (%rax)
leaq 0xe637(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddCeilingOperation() | bool ScalarOperation::AddCeilingOperation() {
modules_.push_back(new OperationPerformer(new Ceiling()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe8fb(%rip), %rcx # 0x168e0
movq %rcx, (%rax)
leaq 0xe4b1(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddRoundingOperation() | bool ScalarOperation::AddRoundingOperation() {
modules_.push_back(new OperationPerformer(new Rounding()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe8c1(%rip), %rcx # 0x16920
movq %rcx, (%rax)
leaq 0xe437(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddRoundingUpOperation() | bool ScalarOperation::AddRoundingUpOperation() {
modules_.push_back(new OperationPerformer(new RoundingUp()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe887(%rip), %rcx # 0x16960
movq %rcx, (%rax)
leaq 0xe3bd(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddRoundingDownOperation() | bool ScalarOperation::AddRoundingDownOperation() {
modules_.push_back(new OperationPerformer(new RoundingDown()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe84d(%rip), %rcx # 0x169a0
movq %rcx, (%rax)
leaq 0xe343(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddUnitStepOperation() | bool ScalarOperation::AddUnitStepOperation() {
modules_.push_back(new OperationPerformer(new UnitStep()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe813(%rip), %rcx # 0x169e0
movq %rcx, (%rax)
leaq 0xe2c9(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddSignOperation() | bool ScalarOperation::AddSignOperation() {
modules_.push_back(new OperationPerformer(new Sign()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe7d9(%rip), %rcx # 0x16a20
movq %rcx, (%rax)
leaq 0xe24f(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddSineOperation() | bool ScalarOperation::AddSineOperation() {
modules_.push_back(new OperationPerformer(new Sine()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe79f(%rip), %rcx # 0x16a60
movq %rcx, (%rax)
leaq 0xe1d5(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddCosineOperation() | bool ScalarOperation::AddCosineOperation() {
modules_.push_back(new OperationPerformer(new Cosine()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe765(%rip), %rcx # 0x16aa0
movq %rcx, (%rax)
leaq 0xe15b(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddTangentOperation() | bool ScalarOperation::AddTangentOperation() {
modules_.push_back(new OperationPerformer(new Tangent()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe72b(%rip), %rcx # 0x16ae0
movq %rcx, (%rax)
leaq 0xe0e1(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddArcsineOperation() | bool ScalarOperation::AddArcsineOperation() {
modules_.push_back(new OperationPerformer(new Arcsine()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe6f1(%rip), %rcx # 0x16b20
movq %rcx, (%rax)
leaq 0xe067(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddArccosineOperation() | bool ScalarOperation::AddArccosineOperation() {
modules_.push_back(new OperationPerformer(new Arccosine()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe6b7(%rip), %rcx # 0x16b60
movq %rcx, (%rax)
leaq 0xdfed(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddArctangentOperation() | bool ScalarOperation::AddArctangentOperation() {
modules_.push_back(new OperationPerformer(new Arctangent()));
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x42c0
movq %rax, %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xe67d(%rip), %rcx # 0x16ba0
movq %rcx, (%rax)
leaq 0xdf73(%rip), %rcx # 0x164a0
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %r14, (%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::AddMagicNumberReplacer(double) | bool ScalarOperation::AddMagicNumberReplacer(double replacement_number) {
if (!use_magic_number_) return false;
modules_.push_back(new MagicNumberReplacer(replacement_number));
use_magic_number_ = false;
return true;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movb 0x8(%rdi), %bl
cmpb $0x1, %bl
jne 0x873f
movq %rdi, %r14
movl $0x10, %edi
movsd %xmm0, 0x8(%rsp)
callq 0x42c0
leaq 0xe59b(%rip), %rcx # 0x16ca0
movq %rcx, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %rax, 0x10(%rsp)
movq 0x18(%r14), %rsi
cmpq 0x20(%r14), %r... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ScalarOperation::Run(double*, bool*) const | bool ScalarOperation::Run(double* number, bool* is_magic_number) const {
if (NULL == number || NULL == is_magic_number) {
return false;
}
*is_magic_number = false;
for (std::vector<ScalarOperation::ModuleInterface*>::const_iterator itr(
modules_.begin());
itr != modules_.end(); ++itr) {
... | testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0x875d
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r15
movb $0x0, (%rdx)
movq 0x10(%rdi), %r12
cmpq 0x18(%rdi), %r12
je 0x87a4
movq %rsi, %r14
addq $0x8, %r12
movq -0x8(%r12), %rdi
movq (%rdi)... | /sp-nitech[P]SPTK/src/math/scalar_operation.cc |
sptk::ReadStream(sptk::Matrix*, std::istream*) | bool ReadStream(sptk::Matrix* matrix_to_read, std::istream* input_stream) {
if (NULL == matrix_to_read || 0 == matrix_to_read->GetNumRow() ||
0 == matrix_to_read->GetNumColumn() || NULL == input_stream ||
input_stream->eof()) {
return false;
}
const int type_byte(sizeof((*matrix_to_read)[0][0]));... | testq %rdi, %rdi
je 0x8d6f
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x8d6f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0xc(%rdi), %ecx
testl %ecx, %ecx
sete %dl
testq %rsi, %rsi
sete %sil
orb %dl, %sil
jne 0x8d72
movq (%rbx), %rdx
movq -0x18(%rdx), %rdx
testb $0x2, 0x20(%rbx,%rdx)
jne 0x8d72
imull %ecx, %eax
... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::ReadStream(sptk::SymmetricMatrix*, std::istream*) | bool ReadStream(sptk::SymmetricMatrix* matrix_to_read,
std::istream* input_stream) {
if (NULL == matrix_to_read) {
return false;
}
const int dim(matrix_to_read->GetNumDimension());
sptk::Matrix matrix(dim, dim);
if (!sptk::ReadStream(&matrix, input_stream)) {
return false;
}
for ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
testq %rdi, %rdi
je 0x8e47
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movl %r14d, %esi
movl %r14d, %edx
callq 0xd624
movq %r12, %rdi
movq %r15, %rsi
callq 0x8d08
movq %r14, 0x10(%rsp)
test... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::SnPrintf<sptk::int24_t>(sptk::int24_t, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, char*) | bool SnPrintf(int24_t data, const std::string& print_format,
std::size_t buffer_size, char* buffer) {
if (print_format.empty() || 0 == buffer_size || NULL == buffer) {
return false;
}
return (std::snprintf(buffer, buffer_size, print_format.c_str(),
static_cast<int>(data)... | xorl %eax, %eax
testq %rcx, %rcx
je 0x908e
testq %rdx, %rdx
je 0x908e
cmpq $0x0, 0x8(%rsi)
je 0x908e
pushq %rax
movq (%rsi), %rax
movzbl 0x2(%rdi), %esi
movl %esi, %r8d
shll $0x10, %r8d
movzbl 0x1(%rdi), %r9d
shll $0x8, %r9d
movzbl (%rdi), %edi
orl %r8d, %edi
leal (%rdi,%r9), %r10d
leal (%r9,%rdi), %r8d
addl $0xff00000... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::ConvertStringToInteger(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int*) | bool ConvertStringToInteger(const std::string& input, int* output) {
if (input.empty() || NULL == output) {
return false;
}
char* end;
int converted_value(static_cast<int>(std::strtol(input.c_str(), &end, 10)));
if (0 == input.compare(end) || '\0' != *end || ERANGE == errno) {
return false;
}
*... | xorl %eax, %eax
testq %rsi, %rsi
je 0x9149
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x913e
movq %rsi, %rbx
movq (%r14), %rdi
movq %rsp, %r12
movq %r12, %rsi
movl $0xa, %edx
callq 0x4370
movq %rax, %r15
movq (%r12), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x40d0
t... | /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... | xorl %eax, %eax
testq %rsi, %rsi
je 0x91b0
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x91a7
movq %rsi, %rbx
movq (%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x4210
movsd %xmm0, (%rsp)
movq (%r15), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x40d0
testl %eax, %... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::AddInLogSpace(double, double) | double AddInLogSpace(double log_x, double log_y) {
if (log_x == log_y) return log_x + kLogTwo;
const double smaller((log_x < log_y) ? log_x : log_y);
const double greater((log_x < log_y) ? log_y : log_x);
const double diff(smaller - greater);
if (diff < kThresholdOfInformationLossInLogSpace) return greater;
... | ucomisd %xmm1, %xmm0
jne 0x95e0
jp 0x95e0
addsd 0x70d6(%rip), %xmm0 # 0x106b0
movapd %xmm0, %xmm2
jmp 0x9623
movapd %xmm1, %xmm2
movapd %xmm0, %xmm1
minsd %xmm2, %xmm1
maxsd %xmm0, %xmm2
subsd %xmm2, %xmm1
movsd 0x70ac(%rip), %xmm0 # 0x106a8
ucomisd %xmm1, %xmm0
ja 0x9623
pushq %rax
movapd %xmm1, %xmm0
movsd %x... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::PrintDataType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::ostream*) | void PrintDataType(const std::string& symbol, std::ostream* stream) {
std::string data_type("");
std::size_t data_size(0);
if ("c" == symbol) {
data_type = "char";
data_size = sizeof(std::int8_t);
} else if ("s" == symbol) {
data_type = "short";
data_size = sizeof(std::int16_t);
} else if ("h... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x6a58(%rip), %rdx # 0x101df
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x6dc4
leaq 0x59cc(%rip), %rsi # 0xf167
movq %r14, %rdi
ca... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<unsigned int>(int, int, std::vector<unsigned int, std::allocator<unsigned int>> 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 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testl %edi, %edi
sets %al
testl %esi, %esi
setle %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
jne 0xbe07
movq %rdx, %r12
movl %esi, %r15d
movl %edi, %r13d
leal (%r15,%r13), %ecx
movq (%rdx), %rax
movq 0x8(%rdx), %rdx... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<double>(int, int, std::vector<double, std::allocator<double>> 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 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testl %edi, %edi
sets %al
testl %esi, %esi
setle %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
jne 0xc050
movq %rdx, %r12
movl %esi, %r15d
movl %edi, %r13d
leal (%r15,%r13), %ecx
movq (%rdx), %rax
movq 0x8(%rdx), %rdx... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<long double>(int, int, std::vector<long double, std::allocator<long double>> 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 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testl %edi, %edi
sets %al
testl %esi, %esi
setle %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
jne 0xc113
movq %rdx, %r12
movl %esi, %r15d
movl %edi, %r13d
leal (%r15,%r13), %eax
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::Matrix::~Matrix() | virtual ~Matrix() {
} | pushq %rbx
movq %rdi, %rbx
leaq 0xa921(%rip), %rax # 0x16d20
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0xc410
callq 0x4290
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xc41f
popq %rbx
jmp 0x4290
popq %rbx
retq
nop
| /sp-nitech[P]SPTK/include/SPTK/math/matrix.h |
sptk::Matrix::Matrix(int, int, std::vector<double, std::allocator<double>> const&) | Matrix::Matrix(int num_row, int num_column, const std::vector<double>& vector)
: num_row_(num_row < 0 ? 0 : num_row),
num_column_(num_column < 0 ? 0 : num_column),
data_(vector),
index_(num_row_) {
for (int i(0); i < num_row_; ++i) {
index_[i] = &data_[i * num_column_];
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
leaq 0x963f(%rip), %rax # 0x16d20
movq %rax, (%rdi)
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movl %esi, 0x8(%rdi)
testl %edx, %edx
cmovgl %edx, %eax
movl %eax, 0xc(%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xe12c
l... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::Resize(int, int) | void Matrix::Resize(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_);
Fill(0.0);
for (int i(0); i < num_row_; ++i) {
index_[i] = &data_[i * num_column_];
}
} | pushq %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movq %rdi, %r15
testl %edx, %edx
cmovgl %edx, %eax
movl %esi, 0x8(%rdi)
movl %eax, 0xc(%rdi)
leaq 0x10(%rdi), %rbx
imull %eax, %esi
movq %rbx, %rdi
callq 0xb2e6
leaq 0x28(%r15), %r14
movslq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xe0fa
... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::At(int, int) | double& Matrix::At(int row, int column) {
if (row < 0 || num_row_ <= row || column < 0 || num_column_ <= column) {
throw std::out_of_range(kErrorMessageForOutOfRange);
}
return index_[row][column];
} | pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
js 0xd9d4
testl %edx, %edx
js 0xd9d4
cmpl %esi, 0x8(%rdi)
jle 0xd9d4
cmpl %edx, 0xc(%rdi)
jle 0xd9d4
movl %esi, %ecx
movq 0x28(%rdi), %rsi
movl %edx, %eax
shlq $0x3, %rax
addq (%rsi,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x4150
mov... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::At(int, int) const | const double& Matrix::At(int row, int column) const {
if (row < 0 || num_row_ <= row || column < 0 || num_column_ <= column) {
throw std::out_of_range(kErrorMessageForOutOfRange);
}
return index_[row][column];
} | pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
js 0xda48
testl %edx, %edx
js 0xda48
cmpl %esi, 0x8(%rdi)
jle 0xda48
cmpl %edx, 0xc(%rdi)
jle 0xda48
movl %esi, %ecx
movq 0x28(%rdi), %rsi
movl %edx, %eax
shlq $0x3, %rax
addq (%rsi,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x4150
mov... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::operator+=(sptk::Matrix const&) | Matrix& Matrix::operator+=(const Matrix& matrix) {
if (num_row_ != matrix.num_row_ || num_column_ != matrix.num_column_) {
throw std::logic_error(kErrorMessageForLogicError);
}
std::transform(data_.begin(), data_.end(), matrix.data_.begin(),
data_.begin(), std::plus<double>());
return *this... | pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0xdad7
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0xdad7
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq %rcx, %rax
je 0xdacc
movq 0x10(%rsi), %rdx
movsd (%rax), %xmm0
addsd (%rdx), %xmm0
movsd %xmm0, (%rax)
addq $0x8, %rax
addq $0x8, %r... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::operator-=(sptk::Matrix const&) | Matrix& Matrix::operator-=(const Matrix& matrix) {
if (num_row_ != matrix.num_row_ || num_column_ != matrix.num_column_) {
throw std::logic_error(kErrorMessageForLogicError);
}
std::transform(data_.begin(), data_.end(), matrix.data_.begin(),
data_.begin(), std::minus<double>());
return *thi... | pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0xdb65
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0xdb65
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq %rcx, %rax
je 0xdb5a
movq 0x10(%rsi), %rdx
movsd (%rax), %xmm0
subsd (%rdx), %xmm0
movsd %xmm0, (%rax)
addq $0x8, %rax
addq $0x8, %r... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::operator-() const | Matrix Matrix::operator-() const {
Matrix result(*this);
result.Negate();
return result;
} | pushq %rbx
movq %rdi, %rbx
callq 0xd76a
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0xddcc
movaps 0x2a07(%rip), %xmm0 # 0x107c0
movsd (%rax), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rax)
addq $0x8, %rax
cmpq %rcx, %rax
jne 0xddb9
movq %rbx, %rax
popq %rbx
retq
nop
| /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::FillDiagonal(double) | void Matrix::FillDiagonal(double value) {
Fill(0.0);
const int num_ones(std::min(num_row_, num_column_));
for (int i(0); i < num_ones; ++i) {
index_[i][i] = value;
}
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rdx
cmpq %rdx, %rdi
je 0xde31
subq %rdi, %rdx
addq $-0x8, %rdx
andq $-0x8, %rdx
addq $0x8, %rdx
xorl %esi, %esi
movsd %xmm0, 0x8(%rsp)
callq 0x4190
movsd 0x8(%rsp), %xmm0
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %eax
cmpl %ecx, %eax
cmovll ... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::GetDeterminant(double*) const | bool Matrix::GetDeterminant(double* determinant) const {
if (num_row_ != num_column_ || num_row_ <= 0 || NULL == determinant) {
return false;
}
const int num_dimension(num_row_);
if (1 == num_dimension) {
*determinant = index_[0][0];
return true;
}
const int num_order(num_dimension - 1);
Mat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jne 0xdfe2
movq %rsi, %rbx
testl %edx, %edx
setle %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0xdff9
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r... | /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];
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x887d(%rip), %rax # 0x16d50
movq %rax, (%rdi)
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movl %esi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x28(%rdi), %r14
leal 0x1(%rsi), %eax
imull %eax, %esi
shrl %esi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movup... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
glfwCreateStandardCursor | GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape)
{
_GLFWcursor* cursor;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (shape != GLFW_ARROW_CURSOR &&
shape != GLFW_IBEAM_CURSOR &&
shape != GLFW_CROSSHAIR_CURSOR &&
shape != GLFW_HAND_CURSOR &&
shape != GLFW_HRESIZE_CURSOR &&
... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x3a8f0(%rip), %r15 # 0x538b8
cmpl $0x0, (%r15)
je 0x18ff7
movl %edi, %r14d
leal -0x36007(%r14), %eax
cmpl $-0x7, %eax
ja 0x19009
leaq 0x2d9b6(%rip), %rsi # 0x4699a
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
movl %r14d, %edx
xorl %eax, %eax
callq 0x17e61
j... | /anael-seghezzi[P]glfw/src/input.c |
glfwShowWindow | GLFWAPI void glfwShowWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformShowWindow(window);
if (window->focusOnShow)
_glfwPlatformFocusWindow(window);
} | pushq %rbx
testq %rdi, %rdi
je 0x1c8c8
leaq 0x37027(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1c8a2
movq %rdi, %rbx
cmpq $0x0, 0x40(%rdi)
je 0x1c8b1
popq %rbx
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rbx
jmp 0x17e61
movq %rbx, %rdi
callq 0x20eda
cmpl $0x0, 0x18(%rbx... | /anael-seghezzi[P]glfw/src/window.c |
glfwHideWindow | GLFWAPI void glfwHideWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformHideWindow(window);
} | testq %rdi, %rdi
je 0x1c956
leaq 0x36f81(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1c948
cmpq $0x0, 0x40(%rdi)
je 0x21fcf
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x17e61
pushq %rax
leaq 0xe7c1(%rip), %rdi # 0x2b11f
leaq 0x2b3ad(%rip), %rsi # 0x47d12
leaq 0x2... | /anael-seghezzi[P]glfw/src/window.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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x33c3c(%rip), %rax # 0x538b8
cmpl $0x0, 0x20560(%rax)
je 0x1fd02
cmpl $0x0, 0x20584(%rax)
jne 0x1fd02
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x1fec0(%rax), %rdi
movq 0x1fed0(%rax), %rsi
movq %rax, %r13
callq *0x205d8(%rax)
movq %rax, %r15
mo... | /anael-seghezzi[P]glfw/src/x11_monitor.c |
testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
const std::string& str) {
std::string output;
output.reserve(str.size());
for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
if (IsValidXmlCharacter(*it))
output.push_back(*it);
return output;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x88a0
movq (%r14), %rax
movl $0x2600, %ebp # imm = 0x2600
movq %rax, %r15
movq 0x8(%r14), %rcx
addq %rax, %rcx
c... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::RecordProperty(testing::TestProperty const&) | void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
std::string xml_element;
TestResult* test_result; // TestResult appropriate for property recording.
if (current_test_info_ != nullptr) {
xml_element = "testcase";
test_result = &(current_test_info_->result_);
} else if (current_tes... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
cmpq $0x0, 0x110(%rdi)
je 0x16ca9
leaq 0xfd80(%rip), %rsi # 0x26a11
leaq 0x8(%rsp), %rdi
callq 0x8a30
movl $0x90, %edi
addq 0x110(%r14), %rdi
jmp 0x16ced
cmpq ... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::UnitTestImpl(testing::UnitTest*) | UnitTestImpl::UnitTestImpl(UnitTest* parent)
: parent_(parent),
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
default_global_test_part_result_reporter_(this),
default_per_thread_test_part_result_reporter_(this),
GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20127(%rip), %rax # 0x373b8
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
addq $0x10, %rdi
callq 0x1c39a
leaq 0x30(%rbx), %rax
leaq 0x1fe6c(%rip), %rcx # 0x37118
movq %rcx, 0x30(%rbx)
movq %rbx, 0x38(%rbx)
leaq 0x40(%rbx), %r14
leaq 0x1fe81(... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest.cc |
testing::internal::ParseInt32(testing::Message const&, char const*, int*) | bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
// Parses the environment variable as a decimal integer.
char* end = nullptr;
const long long_value = strtol(str, &end, 10); // NOLINT
// Has strtol() consumed all characters in the string?
if (*end != '\0') {
// No - an invalid c... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
leaq 0x18(%rsp), %r15
andq $0x0, (%r15)
pushq $0xa
popq %rdx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x87c0
movq (%r15), %rcx
cmpb $0x0, (%rcx)
je 0x17f6c
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xe11a
movq (%rbx), ... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest-port.cc |
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&) | void OnTestEnd(const TestInfo& test_info) override {
SendLn("event=TestEnd&passed=" +
FormatBool((test_info.result())->Passed()) +
"&elapsed_time=" +
StreamableToString((test_info.result())->elapsed_time()) + "ms");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r13
movq %rdi, %r15
leaq 0x90(%rsi), %rdi
callq 0x1d76a
movzbl %al, %edx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20288
leaq 0x7e62(%rip), %rsi # 0x27bd7
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rb... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestCaseEnd(testing::TestSuite const&) | void OnTestCaseEnd(const TestCase& test_case) override {
SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) +
"&elapsed_time=" + StreamableToString(test_case.elapsed_time()) +
"ms");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1f1e2
movzbl %al, %edx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20288
leaq 0x7d90(%rip), %rsi # 0x27bff
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rd... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestIterationEnd(testing::UnitTest const&, int) | void OnTestIterationEnd(const UnitTest& unit_test,
int /* iteration */) override {
SendLn("event=TestIterationEnd&passed=" +
FormatBool(unit_test.Passed()) + "&elapsed_time=" +
StreamableToString(unit_test.elapsed_time()) + "ms");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
callq 0x12cde
movzbl %al, %edx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20288
leaq 0x7cb0(%rip), %rsi # 0x27c19
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rd... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Send(const std::string& message) override {
GTEST_CHECK_(sockfd_ != -1)
<< "Send() can be called only when there is a connection.";
const auto len = static_cast<size_t>(message.length());
if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) {
GTEST_LOG_(WARNIN... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edi
cmpl $-0x1, %edi
jne 0x20142
leaq 0x7782(%rip), %rdx # 0x27882
leaq 0xc(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x440, %ecx # imm = 0x440
callq 0x1ad40
movq 0x17ecc(%rip), %rdi # 0x3... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest-internal-inl.h |
testing::internal::CapturedStream::CapturedStream(int) | explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
# if GTEST_OS_WINDOWS
char temp_dir_path[MAX_PATH + 1] = { '\0' }; // NOLINT
char temp_file_path[MAX_PATH + 1] = { '\0' }; // NOLINT
::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
const UINT success = ::GetTempFileNameA(temp_... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl %esi, (%rdi)
movl %esi, %edi
callq 0x8870
movl %eax, 0x4(%rbx)
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x8(%rbx), %r14
movb $0x0, 0x18(%rbx)
movups 0x7ffd(%rip), %xmm0 # 0x2866c
leaq 0x10(%rsp), %rdi
movu... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest-port.cc |
testing::internal::CapturedStream::GetCapturedString[abi:cxx11]() | std::string GetCapturedString() {
if (uncaptured_fd_ != -1) {
// Restores the original stream.
fflush(nullptr);
dup2(uncaptured_fd_, fd_);
close(uncaptured_fd_);
uncaptured_fd_ = -1;
}
FILE* const file = posix::FOpen(filename_.c_str(), "r");
if (file == nullptr) {
GT... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x4(%rsi)
je 0x20745
xorl %edi, %edi
callq 0x85d0
movl (%r14), %esi
movl 0x4(%r14), %edi
callq 0x8440
movl 0x4(%r14), %edi
callq 0x8a60
orl $-0x1, 0x4(%r14)
movq 0x8(%r14), %rdi
leaq 0x642e(%rip), %rsi # 0x26b7e
call... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest-port.cc |
testing::internal::StripTrailingSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline std::string StripTrailingSpaces(std::string str) {
std::string::iterator it = str.end();
while (it != str.begin() && IsSpace(*--it))
it = str.erase(it);
return str;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %r15
addq %rax, %r15
cmpq %rax, %r15
je 0x20838
movsbl -0x1(%r15), %edi
callq 0x208c2
testb %al, %al
je 0x20838
decq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8660
movq %rax, %r15
movq (%r14), %rax
jmp 0x2080f
movq %rb... | /wapm-packages[P]wabt/third_party/gtest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::GetPrefixUntilComma[abi:cxx11](char const*) | inline std::string GetPrefixUntilComma(const char* str) {
const char* comma = strchr(str, ',');
return comma == nullptr ? str : std::string(str, comma);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0x81b0
testq %rax, %rax
je 0x2087d
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xc78a
jmp 0x2088d
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa... | /wapm-packages[P]wabt/third_party/gtest/googletest/include/gtest/internal/gtest-internal.h |
testing::Message& testing::Message::operator<<<long long>(long long const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
movq (%rsi), %rsi
callq 0x81a0
movq %rbx, %rax
popq %rbx
retq
| /wapm-packages[P]wabt/third_party/gtest/googletest/include/gtest/gtest-message.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::GetOrCreateValue() const | T* GetOrCreateValue() const {
ThreadLocalValueHolderBase* const holder =
static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
if (holder != nullptr) {
return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
}
ValueHolder* const new_holder = default_factory_->Ma... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0x8850
testq %rax, %rax
je 0x20c02
movq %rax, %rdi
callq 0x20c80
movq %rax, %rbx
jmp 0x20c70
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0x80c0
testl %eax, %eax
... | /wapm-packages[P]wabt/third_party/gtest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::ValueHolder, testing::internal::ThreadLocalValueHolderBase>(testing::internal::ThreadLocalValueHolderBase*) | Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
GTEST_CHECK_(typeid(*base) == typeid(Derived));
#endif
#if GTEST_HAS_DOWNCAST_
return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
return dynamic_cast<Derived*>(base); // NOLINT
#else
return static_cast<Derived*>(base); // Poor man's ... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x20cf9
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rdi
leaq 0x16eae(%rip), %rsi # 0x37b48
callq 0x1f9a0
testb %al, %al
jne 0x20cda
leaq 0x6a03(%rip), %rdx # 0x276ad
leaq 0x4(%rsp), %r14
pushq $0x3
popq %rsi
movq %r14, %rdi
movl $0x44d, %ecx ... | /wapm-packages[P]wabt/third_party/gtest/googletest/include/gtest/internal/gtest-port.h |
testing::Message& testing::Message::operator<<<double>(double const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
movsd (%rsi), %xmm0
callq 0x8900
movq %rbx, %rax
popq %rbx
retq
nop
| /wapm-packages[P]wabt/third_party/gtest/googletest/include/gtest/gtest-message.h |
testing::internal::FloatingPoint<float>::AlmostEquals(testing::internal::FloatingPoint<float> const&) const | Bits exponent_bits() const { return kExponentBitMask & u_.bits_; } | movl (%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx # imm = 0x7F800000
sete %cl
testl $0x7fffff, %eax # imm = 0x7FFFFF
setne %al
testb %al, %cl
jne 0x21686
movl (%rsi), %eax
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx # imm = 0x7F800000
sete %cl
testl $0x7fffff, %eax # ... | /wapm-packages[P]wabt/third_party/gtest/googletest/include/gtest/internal/gtest-internal.h |
testing::TestPartResult::TestPartResult(testing::TestPartResult const&) | class GTEST_API_ TestPartResult {
public:
// The possible outcomes of a test part (i.e. an assertion or an
// explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
enum Type {
kSuccess, // Succeeded.
kNonFatalFailure, // Failed but the test can continue.
kFatalFailure, // Failed and the test s... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x8780
movl 0x28(%rbx), %eax
movl %eax, 0x28(%r14)
leaq 0x30(%r14), %rdi
leaq 0x30(%rbx), %rsi
callq 0x8780
addq $0x50, %r14
addq $0x50, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0... | /wapm-packages[P]wabt/third_party/gtest/googletest/include/gtest/gtest-test-part.h |
mbedtls_gcm_setkey | int mbedtls_gcm_setkey( mbedtls_gcm_context *ctx,
mbedtls_cipher_id_t cipher,
const unsigned char *key,
unsigned int keybits )
{
int ret;
const mbedtls_cipher_info_t *cipher_info;
cipher_info = mbedtls_cipher_info_from_values( cipher, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
pushq $0x1
popq %rdx
movl %esi, %edi
movl %ecx, %esi
callq 0x7052
movq %rax, %r15
pushq $-0x14
popq %rax
testq %r15, %r15
je 0x5cb2
cmpl $0x10, 0x20(%r15)
jne 0x5cb2
movq %rbx, %rdi
callq 0x709b
movq %rbx, %rdi
... | /project-everest[P]mbedtls/library/gcm.c |
mbedtls_gcm_starts | int mbedtls_gcm_starts( mbedtls_gcm_context *ctx,
int mode,
const unsigned char *iv,
size_t iv_len,
const unsigned char *add,
size_t add_len )
{
int ret;
unsigned char work_buf[16];
size_t i;
const unsigned char *p;
size... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbp
andq $0x0, 0x20(%rsp)
leaq -0x1(%rcx), %rax
movabsq $0x1fffffffffffffff, %rcx # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rcx, %rax
setae %al
incq %rcx
cmpq %rcx, %r9
setae %cl
orb %al, %cl
jne 0x5de3
movq %r9, %rbx
movq %r8, %r14
m... | /project-everest[P]mbedtls/library/gcm.c |
mbedtls_gcm_update | int mbedtls_gcm_update( mbedtls_gcm_context *ctx,
size_t length,
const unsigned char *input,
unsigned char *output )
{
int ret;
unsigned char ectr[16];
size_t i;
const unsigned char *p;
unsigned char *out_p = output;
size_t use_len, olen = 0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r14
andq $0x0, 0x18(%rsp)
movq %rcx, %rax
subq %rdx, %rax
seta %cl
cmpq %rsi, %rax
setb %dl
pushq $-0x14
popq %rax
testb %dl, %cl
jne 0x61af
movq %rsi, %r15
movq %rdi, %r12
movq 0x158(%rdi), %rsi
addq %r15, %r... | /project-everest[P]mbedtls/library/gcm.c |
mbedtls_gcm_crypt_and_tag | int mbedtls_gcm_crypt_and_tag( mbedtls_gcm_context *ctx,
int mode,
size_t length,
const unsigned char *iv,
size_t iv_len,
const unsigned char *add,
size_t add_len,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rax
movq %rdx, %r12
movq %rdi, %rbx
movq 0x60(%rsp), %r15
movq 0x58(%rsp), %r14
movq 0x50(%rsp), %r13
movq 0x48(%rsp), %rbp
movq 0x40(%rsp), %r9
movq %rcx, %rdx
movq %r8, %rcx
movq %rax, %r8
callq 0x5d59
testl %eax, %eax
jne 0x6353
... | /project-everest[P]mbedtls/library/gcm.c |
mbedtls_gcm_auth_decrypt | int mbedtls_gcm_auth_decrypt( mbedtls_gcm_context *ctx,
size_t length,
const unsigned char *iv,
size_t iv_len,
const unsigned char *add,
size_t add_len,
const unsigned char *tag,
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rax
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rbx
movq 0x58(%rsp), %r14
movq 0x48(%rsp), %r15
subq $0x8, %rsp
leaq 0x8(%rsp), %r10
xorl %r12d, %r12d
xorl %esi, %esi
movq %rbx, %rdx
pushq %r10
pushq %r15
pushq %r14
pushq 0x70(%rsp)
pu... | /project-everest[P]mbedtls/library/gcm.c |
mbedtls_gcm_self_test | int mbedtls_gcm_self_test( int verbose )
{
mbedtls_gcm_context ctx;
unsigned char buf[64];
unsigned char tag_buf[16];
int i, j, ret;
mbedtls_cipher_id_t cipher = MBEDTLS_CIPHER_ID_AES;
for( j = 0; j < 3; j++ )
{
int key_len = 128 + 64 * j;
for( i = 0; i < MAX_TESTS; i++ )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movl %edi, 0xc(%rsp)
leaq 0x7734(%rip), %rax # 0xdb80
movq %rax, 0x78(%rsp)
leaq 0x7bc8(%rip), %rax # 0xe020
movq %rax, 0x70(%rsp)
leaq 0xd8(%rsp), %rbx
leaq 0x76f4(%rip), %r14 # 0xdb60
pushq $0x1... | /project-everest[P]mbedtls/library/gcm.c |
mbedtls_aesni_has_support | int mbedtls_aesni_has_support( unsigned int what )
{
static int done = 0;
static unsigned int c = 0;
if( ! done )
{
asm( "movl $1, %%eax \n\t"
"cpuid \n\t"
: "=c" (c)
:
: "eax", "ebx", "edx" );
done = 1;
}
retur... | cmpb $0x1, 0xf5f5(%rip) # 0x16128
jne 0x6b3d
movl 0xf5f1(%rip), %ecx # 0x1612c
jmp 0x6b53
pushq %rbx
movl $0x1, %eax
cpuid
movl %ecx, 0xf5e1(%rip) # 0x1612c
movb $0x1, 0xf5d6(%rip) # 0x16128
popq %rbx
xorl %eax, %eax
testl %edi, %ecx
setne %al
retq
| /project-everest[P]mbedtls/library/aesni.c |
mbedtls_aesni_crypt_ecb | int mbedtls_aesni_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
asm( "movdqu (%3), %%xmm0 \n\t" // load input
"movdqu (%1), %%xmm1 \n\t" // load round key 0
"pxor... | movl (%rdi), %eax
movq 0x8(%rdi), %rdi
movdqu (%rdx), %xmm0
movdqu (%rdi), %xmm1
pxor %xmm1, %xmm0
addq $0x10, %rdi
subl $0x1, %eax
testl %esi, %esi
je 0x6b95
movdqu (%rdi), %xmm1
aesenc %xmm1, %xmm0
addq $0x10, %rdi
subl $0x1, %eax
jne 0x6b78
movdqu (%rdi), %xmm1
aesenclast %xmm1, %xmm0
jmp 0x6bb0
movdqu (%rdi), %xmm1... | /project-everest[P]mbedtls/library/aesni.c |
mbedtls_aesni_gcm_mult | void mbedtls_aesni_gcm_mult( unsigned char c[16],
const unsigned char a[16],
const unsigned char b[16] )
{
unsigned char aa[16], bb[16], cc[16];
size_t i;
/* The inputs are in big-endian order, so byte-reverse them */
for( i = 0; i < 16; i++ )
{
aa[... | movabsq $0x10, %rcx
xorl %eax, %eax
movq %rcx, %r8
subq $0x1, %r8
jb 0x6be6
movb -0x1(%rsi,%rcx), %r9b
movb %r9b, -0x18(%rsp,%rax)
movb -0x1(%rdx,%rcx), %cl
movb %cl, -0x28(%rsp,%rax)
incq %rax
movq %r8, %rcx
jmp 0x6bc6
leaq -0x18(%rsp), %rax
leaq -0x28(%rsp), %rcx
leaq -0x38(%rsp), %rdx
movdqu (%rax), %xmm0
movdqu (%r... | /project-everest[P]mbedtls/library/aesni.c |
mbedtls_aesni_inverse_key | void mbedtls_aesni_inverse_key( unsigned char *invkey,
const unsigned char *fwdkey, int nr )
{
unsigned char *ik = invkey;
const unsigned char *fk = fwdkey + 16 * nr;
memcpy( ik, fk, 16 );
for( fk -= 16, ik += 16; fk > fwdkey; fk -= 16, ik += 16 )
asm( "movdqu (%0), %%x... | shll $0x4, %edx
movslq %edx, %rax
addq %rsi, %rax
addq $-0x10, %rax
movups 0x10(%rax), %xmm0
movups %xmm0, (%rdi)
addq $0x10, %rdi
cmpq %rsi, %rax
jbe 0x6d53
movdqu (%rax), %xmm0
aesimc %xmm0, %xmm0
movdqu %xmm0, (%rdi)
addq $0x10, %rdi
addq $-0x10, %rax
jmp 0x6d37
movups (%rax), %xmm0
movups %xmm0, (%rdi)
retq
| /project-everest[P]mbedtls/library/aesni.c |
mbedtls_aesni_setkey_enc | int mbedtls_aesni_setkey_enc( unsigned char *rk,
const unsigned char *key,
size_t bits )
{
switch( bits )
{
case 128: aesni_setkey_enc_128( rk, key ); break;
case 192: aesni_setkey_enc_192( rk, key ); break;
case 256: aesni_setkey_enc_256( rk, ... | cmpq $0x100, %rdx # imm = 0x100
je 0x6eea
cmpq $0xc0, %rdx
je 0x6e2b
cmpq $0x80, %rdx
jne 0x6fb0
movdqu (%rsi), %xmm0
movdqu %xmm0, (%rdi)
jmp 0x6db8
pshufd $0xff, %xmm1, %xmm1 # xmm1 = xmm1[3,3,3,3]
pxor %xmm0, %xmm1
pslldq $0x4, %xmm0 # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10... | /project-everest[P]mbedtls/library/aesni.c |
mbedtls_cipher_write_tag | int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
unsigned char *tag, size_t tag_len )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == tag )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( MBEDTLS_ENCRYPT != ctx->operation )
return( MBEDTLS_ERR_CIPHER_... | movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x78ed
movq (%rdi), %rcx
testq %rcx, %rcx
sete %r8b
testq %rsi, %rsi
sete %r9b
orb %r8b, %r9b
jne 0x78ed
cmpl $0x1, 0xc(%rdi)
jne 0x78ed
xorl %eax, %eax
cmpl $0x6, 0x4(%rcx)
jne 0x78ed
movq 0x50(%rdi), %rdi
jmp 0x61be
retq
| /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_check_tag | int mbedtls_cipher_check_tag( mbedtls_cipher_context_t *ctx,
const unsigned char *tag, size_t tag_len )
{
int ret;
if( NULL == ctx || NULL == ctx->cipher_info ||
MBEDTLS_DECRYPT != ctx->operation )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
if( MBEDTLS_M... | movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x7906
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x7906
cmpl $0x0, 0xc(%rdi)
je 0x7907
retq
xorl %eax, %eax
cmpl $0x6, 0x4(%rcx)
jne 0x7906
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
cmpq $0x10, %... | /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_crypt | int mbedtls_cipher_crypt( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen )
{
int ret;
size_t finish_olen;
if( ( ret = mbedtls_cipher_set_iv( ctx, iv, iv... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rdi, %r14
callq 0x71d9
testl %eax, %eax
je 0x7996
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %r14, %r14
je 0x7988... | /project-everest[P]mbedtls/library/cipher.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.