name string | code string | asm string | file string |
|---|---|---|---|
bool run_test_type_conversion<std::shared_ptr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const>>(chaiscript::Boxed_Value const&, bool) | bool run_test_type_conversion(const Boxed_Value &bv, bool expectedpass) {
try {
To ret = chaiscript::boxed_cast<To>(bv);
use(ret);
} catch (const chaiscript::exception::bad_boxed_cast &e) {
if (expectedpass) {
std::cerr << "Failure in run_test_type_conversion: " << e.what() << '\n';
return f... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x76368
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x76252
movq 0x27d40(%rip), %rax # 0x9df70
cmpb $0x0, (%rax)
je 0x7623a
incl 0x8(%rdi)
jmp 0x7623e
lock
incl 0x8(%rdi)
callq 0x376e2
movq 0x10(%rsp), %r... | /ChaiScript[P]ChaiScript/unittests/boxed_cast_test.cpp |
bool chaiscript::Type_Conversions::convertable_type<std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const>>() const | bool convertable_type() const noexcept {
const auto type = user_type<T>().bare_type_info();
return thread_cache().count(type) != 0;
} | pushq %rbx
subq $0x10, %rsp
leaq 0x25686(%rip), %rax # 0x9d9c0
movq %rax, 0x8(%rsp)
callq 0x36726
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x36e60
addq $0x8, %rbx
cmpq %rbx, %rax
setne %al
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x3306e
| /ChaiScript[P]ChaiScript/include/chaiscript/utility/../dispatchkit/../dispatchkit/type_conversions.hpp |
bool chaiscript::Type_Conversions::convertable_type<std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const> const>() const | bool convertable_type() const noexcept {
const auto type = user_type<T>().bare_type_info();
return thread_cache().count(type) != 0;
} | pushq %rbx
subq $0x10, %rsp
leaq 0x247ce(%rip), %rax # 0x9daa0
movq %rax, 0x8(%rsp)
callq 0x36726
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x36e60
addq $0x8, %rbx
cmpq %rbx, %rax
setne %al
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x3306e
| /ChaiScript[P]ChaiScript/include/chaiscript/utility/../dispatchkit/../dispatchkit/type_conversions.hpp |
bool chaiscript::Type_Conversions::convertable_type<std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const> const&>() const | bool convertable_type() const noexcept {
const auto type = user_type<T>().bare_type_info();
return thread_cache().count(type) != 0;
} | pushq %rbx
subq $0x10, %rsp
leaq 0x23efa(%rip), %rax # 0x9d9c0
movq %rax, 0x8(%rsp)
callq 0x36726
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x36e60
addq $0x8, %rbx
cmpq %rbx, %rax
setne %al
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x3306e
| /ChaiScript[P]ChaiScript/include/chaiscript/utility/../dispatchkit/../dispatchkit/type_conversions.hpp |
decltype(auto) chaiscript::boxed_cast<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*&>(chaiscript::Boxed_Value const&, chaiscript::Type_Conversions_State const*) | decltype(auto) boxed_cast(const Boxed_Value &bv, const Type_Conversions_State *t_conversions = nullptr) {
if (!t_conversions || bv.get_type_info().bare_equal(user_type<Type>()) || (t_conversions && !(*t_conversions)->convertable_type<Type>())) {
try {
return detail::Cast_Helper<Type>::cast(bv, t_conve... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x79cd9
movq (%rbx), %rdi
leaq 0x23d8f(%rip), %rax # 0x9d9d0
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x23d72(%rip), %rax # 0x9d9c0
movq %rax, 0x8(%rsi)
movl $0x2, 0x10(%rsi)
callq 0x366b4
t... | /ChaiScript[P]ChaiScript/include/chaiscript/utility/../dispatchkit/../dispatchkit/boxed_cast.hpp |
os_tunnel_linux_add | int
os_tunnel_linux_add(struct os_tunnel *tunnel) {
int result;
if (avl_is_node_added(&tunnel->_node)) {
return -1;
}
result = _handle_tunnel(tunnel, true);
if (!result) {
tunnel->_node.key = tunnel->p.tunnel_if;
avl_insert(&_tunnel_tree, &tunnel->_node);
tunnel->if_index = if_nametoindex(t... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x25(%rbp)
je 0x125e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb... | /OLSR[P]OONF/src/base/os_linux/os_tunnel_linux.c |
handle_ipv4_tunnel | static int
_handle_ipv4_tunnel(struct os_tunnel *tunnel, bool add) {
struct ip_tunnel_parm p;
enum _tunnel_if_type type;
struct ifreq ifr;
int err;
memset(&p, 0, sizeof(p));
memset(&ifr, 0, sizeof(ifr));
p.iph.version = 4;
p.iph.ihl = 5;
p.iph.frag_off = htons(IP_DF);
strscpy(p.name, tunnel->p.tu... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movb %sil, %al
movq %rdi, -0x40(%rbp)
andb $0x1, %al
movb %al, -0x41(%rbp)
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x34, %edx
callq 0x1080
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1080
movb -0x58(%rbp), %al
andb $0xf, %al
orb ... | /OLSR[P]OONF/src/base/os_linux/os_tunnel_linux.c |
handle_ipv6_tunnel | static int
_handle_ipv6_tunnel(struct os_tunnel *tunnel, bool add) {
struct my_ip6_tnl_parm2 p;
enum _tunnel_if_type type;
struct ifreq ifr;
int err;
struct netaddr_str nbuf1, nbuf2;
memset(&p, 0, sizeof(p));
memset(&ifr, 0, sizeof(ifr));
ifr.ifr_ifru.ifru_data = (void *)&p;
if (tunnel->p.base_if[0]... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movb %sil, %al
movq %rdi, -0x68(%rbp)
andb $0x1, %al
movb %al, -0x69(%rbp)
leaq -0xb8(%rbp), %rdi
xorl %esi, %esi
movl $0x4c, %edx
callq 0x1080
leaq -0xe8(%rbp), %rdi
xorl %esi, %esi
movl $0x28, ... | /OLSR[P]OONF/src/base/os_linux/os_tunnel_linux.c |
set_base_tunnel_up | static void
_set_base_tunnel_up(enum _tunnel_if_type type) {
struct ifreq ifr;
int oldflags;
if (!_tunnel_base_up[type]) {
/* make sure base interface is up for incoming tunnel traffic */
memset(&ifr, 0, sizeof(ifr));
strscpy(ifr.ifr_name, _tunnel_base_if[type], IF_NAMESIZE);
if (ioctl(os_system... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
movl %edi, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %ecx
leaq 0x2405(%rip), %rax # 0x41c0
testb $0x1, (%rax,%rcx)
jne 0x1fe4
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1080
leaq -0x58(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %ecx... | /OLSR[P]OONF/src/base/os_linux/os_tunnel_linux.c |
select_wrapper | int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset... | testl %edi, %edi
jns 0x1080
pushq %rax
callq 0x1030
movl $0x16, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
| /nomaster[P]curl/tests/libtest/first.c |
HelpIRCCommand::trigger(IRC_Bot*, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) | void HelpIRCCommand::trigger(IRC_Bot *source, std::string_view in_channel, std::string_view nick, std::string_view parameters) {
Jupiter::IRC::Client::Channel *channel = source->getChannel(in_channel);
if (channel != nullptr)
{
int access = source->getAccessLevel(*channel, nick);
if (parameters.empty()) {
for... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
leaq 0x10(%rbp), %rax
movq %rax, -0x208(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
... | /JAJames[P]Jupiter-Bot/src/Plugins/CoreCommands/CoreCommands.cpp |
RehashGenericCommand::trigger(std::basic_string_view<char, std::char_traits<char>>) | Jupiter::GenericCommand::ResponseLine *RehashGenericCommand::trigger(std::string_view parameters) {
size_t hash_errors = Jupiter::rehash();
if (hash_errors == 0)
return new Jupiter::GenericCommand::ResponseLine(string_printf("All %u objects were successfully rehashed.", Jupiter::getRehashableCount()), GenericComma... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
callq 0xa960
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xbe6b
movl $0x30, %edi
callq 0xa170
movq %rax, -0x90(%rbp)
movb $0x1, -0x55(%rbp)
callq 0xa550
movq %rax, -0x88(%rbp)
jmp 0xbdde
movq -0x88(%rb... | /JAJames[P]Jupiter-Bot/src/Plugins/CoreCommands/CoreCommands.cpp |
Generic_Command_As_Console_Command<VersionGenericCommand>::Generic_Command_As_Console_Command() | Generic_Command_As_Console_Command<T>::Generic_Command_As_Console_Command() : ConsoleCommand() {
size_t index = 0;
while (index != T::instance.getTriggerCount()) {
this->addTrigger(T::instance.getTrigger(index++));
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xac30
movq -0x38(%rbp), %rax
movq 0x88ec(%rip), %rcx # 0x14fb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x8916(%rip), %rdi #... | /JAJames[P]Jupiter-Bot/src/Bot/src/../include/Console_Command.h |
auto jessilib::word_split_once<std::basic_string_view<char, std::char_traits<char>>, char const*, char const*, char>(char const*, char const*, char) | constexpr auto word_split_once(ItrT begin, EndT end, ElementT in_whitespace) {
static_assert(sizeof...(OptionalMemberT) <= 1, "Too many member types specified for OptionalMemberT");
using MemberT = std::tuple_element_t<0, std::tuple<OptionalMemberT..., std::basic_string<ElementT>>>;
std::pair<MemberT, MemberT> resu... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movb %cl, %al
movq %rdi, -0x78(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movb %al, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa350
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0xcf2b
movq -0x80(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (... | /JAJames[P]Jupiter-Bot/src/Jupiter/src/jessilib/src/common/../include/jessilib/word_split.hpp |
Generic_Command_As_Console_Command<RehashGenericCommand>::trigger(std::basic_string_view<char, std::char_traits<char>>) | void Generic_Command_As_Console_Command<T>::trigger(std::string_view parameters) {
std::unique_ptr<Jupiter::GenericCommand::ResponseLine> response_line{ T::instance.trigger(parameters) };
while (response_line != nullptr) {
auto& out_stream = response_line->type == Jupiter::GenericCommand::DisplayType::PublicError
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0x5ad5(%rip), %rax # 0x14f38
movq (%rax), %rax
movq 0x5acb(%r... | /JAJames[P]Jupiter-Bot/src/Bot/src/../include/Console_Command.h |
bsplib::A2A::send(int, void const*, unsigned long) | void * A2A::send( int dst_pid, const void * data, std::size_t size )
{
assert( dst_pid >= 0 );
assert( dst_pid < m_nprocs );
assert( m_send_cap == m_send_bufs.size() / m_nprocs );
std::size_t offset = m_send_sizes[ dst_pid ];
if ( m_send_cap < offset + size ) {
std::size_t new_cap =
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0xa29f
movq %rcx, %rbx
movl %esi, %ecx
movq %rdi, %r15
movl 0x8(%rdi), %esi
cmpl %ecx, %esi
jle 0xa2be
movq %rdx, %r8
movq 0x20(%r15), %r14
movq 0xa8(%r15), %rdi
movq 0xb0(%r15), %rax
subq %rdi, %rax
xorl %edx, %edx
divq %r... | /wijnand-suijlen[P]bsponmpi/src/a2a.cc |
bsplib::A2A::exchange() | void A2A::exchange( )
{
std::size_t max_recv = 0, max_bruck_vol = 0;
std::size_t new_cap = m_send_cap;
{
#ifdef PROFILE
TicToc t( TicToc::MPI_META_A2A, 4*sizeof(std::size_t)*m_nprocs );
#endif
// exchange data sizes.
MPI_Alltoall( m_send_sizes.data(), sizeof(std::size_t), MPI_BY... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movslq 0x8(%rdi), %r15
shlq $0x5, %r15
movl $0x8, %edi
callq 0x97be
movl %eax, 0x10(%rsp)
leaq 0x30(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x6290
movaps (%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movq %r15, 0x28(%r... | /wijnand-suijlen[P]bsponmpi/src/a2a.cc |
bsplib::Unbuf::wait() | void Unbuf :: wait( )
{
while (true)
{
int outcount = MPI_UNDEFINED;
MPI_Waitsome( int(m_reqs.size()), m_reqs.data(), &outcount,
m_ready.data(), MPI_STATUSES_IGNORE );
if (outcount == MPI_UNDEFINED )
break;
for (int i = 0; i < outcount; ++i ) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0xffff8002, %ebp # imm = 0xFFFF8002
leaq 0xc(%rsp), %r14
movl %ebp, (%r14)
movq 0x48(%rdi), %rsi
movq 0x50(%rdi), %rdi
subq %rsi, %rdi
shrq $0x3, %rdi
movq 0x60(%rbx), %rcx
movq %r14, %rdx
xorl %r8d, %r8d
callq 0x62a0
mo... | /wijnand-suijlen[P]bsponmpi/src/unbuf.cc |
bsplib::exception::~exception() | exception( const exception & e )
: m_stream( e.m_stream.str() )
, m_buf( )
{} | pushq %rbx
movq %rdi, %rbx
leaq 0xcd23(%rip), %rax # 0x18c78
movq %rax, (%rdi)
movq 0x180(%rdi), %rdi
leaq 0x190(%rbx), %rax
cmpq %rax, %rdi
je 0xbf76
movq (%rax), %rsi
incq %rsi
callq 0x62c0
leaq 0x8(%rbx), %rdi
movq 0xd027(%rip), %rsi # 0x18fa8
callq 0x6140
leaq 0x78(%rbx), %rdi
callq 0x60c0
movq %rbx, %rdi... | /wijnand-suijlen[P]bsponmpi/src/exception.h |
bsplib::Rdma::hpget(int, unsigned long, unsigned long, void*, unsigned long) | void Rdma::hpget( int src_pid, Memslot src_slot, size_t src_offset,
void * dst, size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::HPGET );
#endif
if ( size < m_min_n_hp_msg_size ) {
get( src_pid, src_slot, src_offset, dst, size );
return;
}
assert( !( slot( m_pid, src_slot ).sta... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %r12
movq %r8, %r13
movq %rcx, 0x8(%rsp)
movq %rdx, %rbp
movl %esi, %ebx
movq %rdi, %r14
movq %r8, 0x10(%rsp)
movl $0x6, %edi
callq 0x97be
movl %eax, 0x20(%rsp)
leaq 0x40(%rsp), %r15
movl $0x1, %edi
movq %r15, %rsi
callq 0x6290... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
spawner::Spawner::Spawner<0ul, 1ul, 2ul, 3ul, 4ul, 5ul, 6ul, 7ul, 8ul, 9ul, 10ul, 11ul, 12ul, 13ul, 14ul, 15ul, 16ul, 17ul, 18ul, 19ul, 20ul>(std::vector<char, std::allocator<char>>&&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul, 6ul, 7ul, 8ul, 9ul, 10ul, 11ul, 12ul, 13ul, 14ul, 15ul, 16ul, 17ul, ... | Spawner(std::vector<char>&& pRodata, std::integer_sequence<size_t, I...>)
: fn({[this](){decodeParam(typename StateTraits<State(I)>::type());}...})
, mRodata(std::move(pRodata))
, mRefPos(std::string_view((char*)mRodata.data(), mRodata.size()).find("LoggerRefXD"))
{
if (std::str... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rdi, (%rdi)
leaq 0x4bb(%rip), %rax # 0x2e38
movq %rax, 0x18(%rdi)
leaq 0x4b6(%rip), %rax # 0x2e3e
movq %rax, 0x10(%rdi)
andq $0x0, 0x28(%rdi)
movq %rdi, 0x20(%rdi)
leaq 0x532(%rip), %rax # 0x2ece
mo... | /therooftopprinz[P]Logless/src/spawner.cpp |
spawner::Spawner::decodeParam(spawner::tag) | void decodeParam(tag pTag)
{
auto pData = pTag.data;
auto ntok = findNextToken('%', ';', tokenFormat, mLogPoint);
size_t sglen = uintptr_t(ntok)-uintptr_t(mLogPoint);
std::string logSeg(mLogPoint, sglen);
// std::cout << "state: Tag: " << std::hex << std::setw(2) << s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x100478(%rdi), %rdx
movq 0x1002d0(%rdi), %rcx
pushq $0x25
popq %rdi
pushq $0x3b
popq %rsi
callq 0x31ce
movq %rax, %r14
movq 0x1002d0(%rbx), %rsi
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x28(%rsp), %r15
movq %r15... | /therooftopprinz[P]Logless/src/spawner.cpp |
void spawner::Spawner::decodeParam<unsigned int>(unsigned int) | void decodeParam(T i)
{
if (sizeof(T) == mReadSz)
{
std::memcpy(&i, mReadBuff, sizeof(i));
snprintf(fmtbuf, sizeof(fmtbuf), tokenFormat.c_str(), i);
// std::cout << "state: " << std::dec << unsigned(mState) << "format: " << tokenFormat.c_str() << " value: "... | cmpq $0x4, 0x1002c0(%rdi)
jne 0x36a0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x2bc(%rdi), %ecx
leaq 0x100498(%rdi), %r14
movq 0x100478(%rdi), %rdx
movl $0x4000, %esi # imm = 0x4000
movq %r14, %rdi
xorl %eax, %eax
callq 0x22a0
leaq 0x100300(%rbx), %rdi
movq %r14, %rsi
callq 0x21b0
movl $0x3, 0x2b... | /therooftopprinz[P]Logless/src/spawner.cpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::setCategoryRatesWithIndex(int, double const*) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::setCategoryRatesWithIndex(int categoryRatesIndex,
const double* inCategoryRates) {
if (categoryRatesIndex < 0 || categoryRatesIndex >= kEigenDecompCount)
return BEAGLE_ERROR_OUT_OF_RAN... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0x68def
movq (%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x30(%rcx), %eax
jl 0x68dfc
movl $0xfffffffb, 0x24(%rsp) # imm = 0xFFFFFFFB
jmp 0x68e7c
movq (%rsp), %rax
movq 0x78(%rax... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::setTransitionMatrices(int const*, double const*, double const*, int) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::setTransitionMatrices(const int* matrixIndices,
const double* inMatrices,
const double* paddedValues,
... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x69118
movq (%rsp), %rax
movq 0x40(%rsp), %rcx
movl 0x30(%rsp), %edx
imull 0x24(%r... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::convolveTransitionMatrices(int const*, int const*, int const*, int) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::convolveTransitionMatrices(const int* firstIndices,
const int* secondIndices,
const int* resultIndices,
int matrixCount) {
#ifdef BEAGLE_DEBUG_FLOW
fprintf(stderr, "\t Entering BeagleCPUImpl::convolveTransitionMatrices \n");
#endif
... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x70(%rsp)
movl $0x0, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
cmpl -0x24(%rsp), %eax
jge 0x69473
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movl (%ra... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::updateTransitionMatrices(int, int const*, int const*, int const*, double const*, int) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::updateTransitionMatrices(int eigenIndex,
const int* probabilityIndices,
const int* firstDerivativeIndices,
const int* secondDeriv... | pushq %rbx
subq $0x50, %rsp
movl 0x60(%rsp), %eax
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq 0x70(%rax), %rdi
movl 0x44(%rsp), %esi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x20... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::updatePartialsByPartition(int const*, int) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::updatePartialsByPartition(const int* operations,
int count) {
int returnCode = BEAGLE_ERROR_GENERAL;
if (kThreadingEnabled) {
returnCode = upPartialsByPartitionAsync(operations,
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
testb $0x1, 0x13c(%rax)
je 0x699f8
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
movq (%rdi), %rax
callq *0x1f8(%rax)
movl %eax, 0x10... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::updatePrePartialsByPartition(int const*, int) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::updatePrePartialsByPartition(const int* operations,
int count) {
int returnCode = BEAGLE_ERROR_GENERAL;
if (kThreadingEnabled) {
// TODO
// returnCode = upPrePartialsByP... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
testb $0x1, 0x13c(%rax)
je 0x69a6e
jmp 0x69aa0
movq (%rsp), %rdi
movb $0x1, 0xf(%rsp)
movb 0xf(%rsp), %sil
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ec... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::accumulateScaleFactors(int const*, int, int) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateScaleFactors(const int* scalingIndices,
int count,
int cumulativeScalingIndex) {
if (kFlags & BEAGLE_FLAG_SCALING_AUTO) {
REALTYPE* cumulativ... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rax), %rax
andq $0x80, %rax
cmpq $0x0, %rax
je 0x69c12
movq (%rsp), %rax
movq 0xc0(%rax), %rax
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movq (%... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::removeScaleFactorsByPartition(int const*, int, int, int) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::removeScaleFactorsByPartition(const int* scalingIndices,
int count,
int cumulativeScalingIndex,
... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x90(%rax), %rcx
movslq 0x3c(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x38(%rsp)
movq 0x90(%rax), %rcx
movl 0x3c(%rsp), %edx
addl $0x1, %e... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::calculateRootLogLikelihoods(int const*, int const*, int const*, int const*, int, double*) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::calculateRootLogLikelihoods(const int *bufferIndices,
const int *categoryWeightsIndices,
const int *stateFrequencie... | subq $0x58, %rsp
movq 0x60(%rsp), %rax
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movl %r9d, 0x24(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, 0x24(%rsp)
jne 0x6a475
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
andq $0x80, %rax
cmpq $0x0, ... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::calculateEdgeLogLikelihoods(int const*, int const*, int const*, int const*, int const*, int const*, int const*, int const*, int, double*, double*, double*) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::calculateEdgeLogLikelihoods(const int* parentBufferIndices,
const int* childBufferIndices,
const int* probabilityIndices,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq 0xf0(%rsp), %rax
movq 0xe8(%rsp), %rax
movq 0xe0(%rsp), %rax
movl 0xd8(%rsp), %eax
movq 0xd0(%rsp), %rax
movq 0xc8(%rsp), %rax
movq 0xc0(%rsp), %rax
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%r... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::getDerivatives(double*, double*) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::getDerivatives(double* outSumFirstDerivative,
double* outSumSecondDerivative) {
*outSumFirstDerivative = 0.0;
for (int i = 0; i < kPatternCount; i++) {
*outSumFirstDerivative += outFirstDeri... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, (%rax)
movl $0x0, -0x1c(%rsp)
movq -0x28(%rsp), %rcx
movl -0x1c(%rsp), %eax
cmpl 0x14(%rcx), %eax
jge 0x6b202
movq -0x28(%rsp), %rax
movq 0x118(... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::getSiteLogLikelihoods(double*) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::getSiteLogLikelihoods(double* outLogLikelihoods) {
if (kPatternsReordered) {
REALTYPE* outLogLikelihoodsOriginalOrder = (REALTYPE*) malloc(sizeof(REALTYPE) * kPatternCount);
for (int i=0; i < kPatternCount; i++) {
outLogLikelihoo... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x51(%rax)
je 0x6b32a
movq (%rsp), %rax
movslq 0x14(%rax), %rdi
shlq $0x3, %rdi
callq 0x62d90
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x14(%rcx), %eax
jge 0x6b3... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPU4StateSSEImpl<double, 2, 0>::calcPartialsPartials(double*, double const*, double const*, double const*, double const*, int, int) | BEAGLE_CPU_4_SSE_TEMPLATE
void BeagleCPU4StateSSEImpl<BEAGLE_CPU_4_SSE_DOUBLE>::calcPartialsPartials(double* destP,
const double* partials_q,
const double* matrices_q,
... | subq $0x668, %rsp # imm = 0x668
movl 0x678(%rsp), %eax
movl 0x670(%rsp), %eax
movq %rdi, 0x278(%rsp)
movq %rsi, 0x270(%rsp)
movq %rdx, 0x268(%rsp)
movq %rcx, 0x260(%rsp)
movq %r8, 0x258(%rsp)
movq %r9, 0x250(%rsp)
movq 0x278(%rsp), %rcx
movq %rcx, -0x78(%rsp)
movl 0x14(%rcx), %eax
addl 0x1c(%rcx), %eax
subl ... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateSSEImpl.hpp |
beagle::cpu::BeagleCPU4StateImpl<double, 2, 0>::calcRootLogLikelihoods(int, int, int, int, double*) | BEAGLE_CPU_TEMPLATE
int BeagleCPU4StateImpl<BEAGLE_CPU_GENERIC>::calcRootLogLikelihoods(const int bufferIndex,
const int categoryWeightsIndex,
const int stateFrequenciesIndex,
... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl %edx, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
movl %r8d, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xb0(%rax), %rcx
movslq 0x5c(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, 0x40(%rsp)
movq 0xa0(%rax), %rax
movslq 0x58(%r... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::calcRootLogLikelihoodsPerCategory(int, int, int, double*) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::calcRootLogLikelihoodsPerCategory(
const int bufferIndex,
const int stateFrequenciesIndex,
const int scalingFactorsIndex,
double* outLogLikelihoodPerCategory) {
int returnCode = BEAGLE_SUCCESS;
const REALTYPE* rootParti... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movl %edx, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movq %r8, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x54(%rsp)
movq 0xb0(%rax), %rcx
movslq 0x6c(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, 0x48(%rsp)
movq 0xa8(%rax), %rax
movslq 0x68(%rsp)... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPU4StateSSEImpl<double, 2, 0>::calcEdgeLogLikelihoodsByPartition(int const*, int const*, int const*, int const*, int const*, int const*, int const*, int, double*) | BEAGLE_CPU_4_SSE_TEMPLATE
void BeagleCPU4StateSSEImpl<BEAGLE_CPU_4_SSE_DOUBLE>::calcEdgeLogLikelihoodsByPartition(
const int* parentBufferIndices,
const int* childBufferIndices,
... | subq $0x6f8, %rsp # imm = 0x6F8
movq 0x718(%rsp), %rax
movl 0x710(%rsp), %eax
movq 0x708(%rsp), %rax
movq 0x700(%rsp), %rax
movq %rdi, 0x358(%rsp)
movq %rsi, 0x350(%rsp)
movq %rdx, 0x348(%rsp)
movq %rcx, 0x340(%rsp)
movq %r8, 0x338(%rsp)
movq %r9, 0x330(%rsp)
movq 0x358(%rsp), %rax
movq %rax, (%rsp)
movq 0xe... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateSSEImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::calcEdgeLogLikelihoodsSecondDerivByPartition(int const*, int const*, int const*, int const*, int const*, int const*, int const*, int const*, int const*, int, double*, double*, double*) | BEAGLE_CPU_TEMPLATE
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::calcEdgeLogLikelihoodsSecondDerivByPartition(
const int* parentBufferIndices,
const int* childBufferIndices,
c... | subq $0x158, %rsp # imm = 0x158
movq 0x198(%rsp), %rax
movq 0x190(%rsp), %rax
movq 0x188(%rsp), %rax
movl 0x180(%rsp), %eax
movq 0x178(%rsp), %rax
movq 0x170(%rsp), %rax
movq 0x168(%rsp), %rax
movq 0x160(%rsp), %rax
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
movq %rcx, 0x138(%rsp)
m... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::calcEdgeLogLikelihoodsMulti(int const*, int const*, int const*, int const*, int const*, int const*, int, double*) | BEAGLE_CPU_TEMPLATE
int BeagleCPUImpl<BEAGLE_CPU_GENERIC>::calcEdgeLogLikelihoodsMulti(const int* parentBufferIndices,
const int* childBufferIndices,
const int* probabilityIndices,
... | subq $0x1d8, %rsp # imm = 0x1D8
movq 0x1f0(%rsp), %rax
movl 0x1e8(%rsp), %eax
movq 0x1e0(%rsp), %rax
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq %rcx, 0x1b8(%rsp)
movq %r8, 0x1b0(%rsp)
movq %r9, 0x1a8(%rsp)
movq 0x1d0(%rsp), %rax
movq %rax, 0x48(%rsp)
movslq 0x14(%rax), %rax
mov... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::accumulateDerivatives(double*, double*, double*) | BEAGLE_CPU_TEMPLATE
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivatives(double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
if (outDerivatives == N... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7c293
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x62780
jmp 0x7c2ab
movq (%rsp), %rdi
movq 0x18(%rsp)... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPU4StateImpl<double, 2, 0>::calcStatesStates(double*, int const*, double const*, int const*, double const*, int, int) | BEAGLE_CPU_TEMPLATE
void BeagleCPU4StateImpl<BEAGLE_CPU_GENERIC>::calcStatesStates(REALTYPE* destP,
const int* states1,
const REALTYPE* matrices1,
... | movl 0x10(%rsp), %eax
movl 0x8(%rsp), %eax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x50(%rsp)
movl $0x0, -0x34(%rsp)
movq -0x50(%rsp), %rcx
movl -0x34(%rsp), %eax
cmpl 0x34(%rcx), %eax
jge 0x... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateImpl.hpp |
beagle::cpu::BeagleCPU4StateImpl<double, 2, 0>::calcStatesPartials(double*, int const*, double const*, double const*, double const*, int, int) | BEAGLE_CPU_TEMPLATE
void BeagleCPU4StateImpl<BEAGLE_CPU_GENERIC>::calcStatesPartials(REALTYPE* destP,
const int* states1,
const REALTYPE* matrices1,
... | subq $0x90, %rsp
movl 0xa0(%rsp), %eax
movl 0x98(%rsp), %eax
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movq %r9, 0x60(%rsp)
movq 0x88(%rsp), %rax
movq %rax, -0x80(%rsp)
movl $0x0, 0x5c(%rsp)
movq -0x80(%rsp), %rcx
movl 0x5c(%rsp), %eax
cmpl 0x34(%rcx), ... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateImpl.hpp |
beagle::cpu::BeagleCPU4StateImpl<double, 2, 0>::calcEdgeLogLikelihoods(int, int, int, int, int, int, double*) | BEAGLE_CPU_TEMPLATE
int BeagleCPU4StateImpl<BEAGLE_CPU_GENERIC>::calcEdgeLogLikelihoods(const int parIndex,
const int childIndex,
const int probIndex,
... | subq $0x158, %rsp # imm = 0x158
movq 0x168(%rsp), %rax
movl 0x160(%rsp), %eax
movq %rdi, 0x150(%rsp)
movl %esi, 0x14c(%rsp)
movl %edx, 0x148(%rsp)
movl %ecx, 0x144(%rsp)
movl %r8d, 0x140(%rsp)
movl %r9d, 0x13c(%rsp)
movq 0x150(%rsp), %rcx
movq %rcx, (%rsp)
movq 0xb0(%rcx), %rax
movslq 0x14c(%rsp), %rdx
movq ... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateImpl.hpp |
beagle::cpu::BeagleCPU4StateImpl<double, 2, 0>::calcPartialsPartialsAutoScaling(double*, double const*, double const*, double const*, double const*, int*) | BEAGLE_CPU_TEMPLATE
void BeagleCPU4StateImpl<BEAGLE_CPU_GENERIC>::calcPartialsPartialsAutoScaling(REALTYPE* destP,
const REALTYPE* partials1,
const REALTYPE* matrices1,
... | subq $0x1d8, %rsp # imm = 0x1D8
movq 0x1e0(%rsp), %rax
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq %rcx, 0x1b8(%rsp)
movq %r8, 0x1b0(%rsp)
movq %r9, 0x1a8(%rsp)
movq 0x1d0(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x1a4(%rsp)
movq (%rsp), %rcx
movl 0x1a4(%rsp), %eax
cmpl 0x34(%rc... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::~BeagleCPUImpl() | BEAGLE_CPU_TEMPLATE
BeagleCPUImpl<BEAGLE_CPU_GENERIC>::~BeagleCPUImpl() {
// free all that stuff...
// If you delete partials, make sure not to delete the last element
// which is TEMP_SCRATCH_PARTIAL twice.
for(unsigned int i=0; i<kEigenDecompCount; i++) {
if (gCategoryWeights[i] != NULL)
... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x61400
movq 0x8(%rsp), %rdi
callq 0x61b60
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::calcCrossProductsPartials(double const*, double const*, double const*, double const*, double, double*, double*) | BEAGLE_CPU_TEMPLATE
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::calcCrossProductsPartials(const REALTYPE *postOrderPartial,
const REALTYPE *preOrderPartial,
const double *categoryRates,
... | subq $0xf8, %rsp
movq 0x100(%rsp), %rax
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rcx, 0xd8(%rsp)
movq %r8, 0xd0(%rsp)
vmovsd %xmm0, 0xc8(%rsp)
movq %r9, 0xc0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0xbc(%rsp)
movq 0x28(%rsp), %rcx
movl 0xbc(%rsp), %eax
cmpl 0x14(%rcx)... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::calcStatesPartials(double*, int const*, double const*, double const*, double const*, int, int) | BEAGLE_CPU_TEMPLATE
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::calcStatesPartials(REALTYPE* destP,
const int* states1,
const REALTYPE* matrices1,
... | subq $0x18, %rsp
movl 0x28(%rsp), %eax
movl 0x20(%rsp), %eax
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq %rcx, -0x8(%rsp)
movq %r8, -0x10(%rsp)
movq %r9, -0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, -0x80(%rsp)
movl 0x24(%rax), %ecx
movl %ecx, -0x1c(%rsp)
movl -0x1c(%rsp), %ecx
addl $0x2, %ecx
mov... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::calcEdgeLogLikelihoodsByPartition(int const*, int const*, int const*, int const*, int const*, int const*, int const*, int, double*) | BEAGLE_CPU_TEMPLATE
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::calcEdgeLogLikelihoodsByPartition(
const int* parentBufferIndices,
const int* childBufferIndices,
const int* p... | subq $0x138, %rsp # imm = 0x138
movq 0x158(%rsp), %rax
movl 0x150(%rsp), %eax
movq 0x148(%rsp), %rax
movq 0x140(%rsp), %rax
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq %rcx, 0x118(%rsp)
movq %r8, 0x110(%rsp)
movq %r9, 0x108(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x8(%rsp)
movl ... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::rescalePartials(double*, double*, double*, int) | BEAGLE_CPU_TEMPLATE
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::rescalePartials(REALTYPE* destP,
REALTYPE* scaleFactors,
REALTYPE* cumulativeScaleFactors,
const int fillWithOnes) {
if (DEBUGGING_OUTPUT) {
std::cerr << "destP (before rescale): \n";// << destP << "\n";
for(int i=0... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x40(%rsp)
movq (%rsp), %rcx
movl 0x40(%rsp), %eax
cmpl 0x14(%rcx), %eax
jge 0x86dda
movq (%rsp), %rcx
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0,... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 2, 0>::rescalePartialsByPartition(double*, double*, double*, int, int) | BEAGLE_CPU_TEMPLATE
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::rescalePartialsByPartition(REALTYPE* destP,
REALTYPE* scaleFactors,
REALTYPE* cumulativeScaleFactors,
... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movl %r8d, 0x54(%rsp)
movl %r9d, 0x50(%rsp)
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
movq 0x90(%rax), %rcx
movslq 0x50(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x4c(%rsp)
movq 0x90(%rax), %rax
movl 0x50(%rsp),... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 2, 0>::accumulateDerivativesDispatch1<false>(double*, double*, double*) | BEAGLE_CPU_TEMPLATE template <bool DoDerivatives>
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesDispatch1(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
if (outSumDerivatives == NULL) {
accumulateDerivativesDispatch2<DoDerivati... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x89e03
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x62410
jmp 0x89e1b
movq (%rsp), %rdi
movq 0x18(%rsp)... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 2, 0>::accumulateDerivativesDispatch1<true>(double*, double*, double*) | BEAGLE_CPU_TEMPLATE template <bool DoDerivatives>
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesDispatch1(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
if (outSumDerivatives == NULL) {
accumulateDerivativesDispatch2<DoDerivati... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x89e63
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x61fc0
jmp 0x89e7b
movq (%rsp), %rdi
movq 0x18(%rsp)... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPU4StateSSEImpl<double, 2, 0>::accumulateDerivativesImpl<false, false, false>(double*, double*, double*) | void BeagleCPU4StateSSEImpl<BEAGLE_CPU_4_SSE_DOUBLE>::accumulateDerivativesImpl(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
V_Real vSum = VEC_SETZERO();
V_Real vSumSquared = VEC_SETZERO();
int k = 0;
for (; k < kPatternCount - 1; k +=... | subq $0x98, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, -0x80(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x60(%rsp)
vmovapd 0x60(%rsp), %xmm1
vmovapd %xmm1, (%rsp)
vmovapd %xmm0, 0x50(%rsp)
vmovapd 0x50(%rsp), %xmm0
vmovapd %xmm0, -0x... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateSSEImpl.hpp |
void beagle::cpu::BeagleCPU4StateSSEImpl<double, 2, 0>::accumulateDerivativesImpl<false, false, true>(double*, double*, double*) | void BeagleCPU4StateSSEImpl<BEAGLE_CPU_4_SSE_DOUBLE>::accumulateDerivativesImpl(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
V_Real vSum = VEC_SETZERO();
V_Real vSumSquared = VEC_SETZERO();
int k = 0;
for (; k < kPatternCount - 1; k +=... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, -0x80(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0xf0(%rsp)
vmovapd 0xf0(%rsp), %xmm1
vmovapd %xmm1, (%rsp)
vmovapd %xmm0, 0xe0(%rsp)
vmovapd 0xe0(%rsp)... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateSSEImpl.hpp |
void beagle::cpu::BeagleCPU4StateSSEImpl<double, 2, 0>::accumulateDerivativesImpl<false, true, false>(double*, double*, double*) | void BeagleCPU4StateSSEImpl<BEAGLE_CPU_4_SSE_DOUBLE>::accumulateDerivativesImpl(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
V_Real vSum = VEC_SETZERO();
V_Real vSumSquared = VEC_SETZERO();
int k = 0;
for (; k < kPatternCount - 1; k +=... | subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, -0x80(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0xd0(%rsp)
vmovapd 0xd0(%rsp), %xmm1
vmovapd %xmm1, (%rsp)
vmovapd %xmm0, 0xc0(%rsp)
vmovapd 0xc0(%rsp)... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateSSEImpl.hpp |
void beagle::cpu::BeagleCPU4StateSSEImpl<double, 2, 0>::accumulateDerivativesImpl<false, true, true>(double*, double*, double*) | void BeagleCPU4StateSSEImpl<BEAGLE_CPU_4_SSE_DOUBLE>::accumulateDerivativesImpl(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
V_Real vSum = VEC_SETZERO();
V_Real vSumSquared = VEC_SETZERO();
int k = 0;
for (; k < kPatternCount - 1; k +=... | subq $0x198, %rsp # imm = 0x198
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, -0x80(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x160(%rsp)
vmovapd 0x160(%rsp), %xmm1
vmovapd %xmm1, (%rsp)
vmovapd %xmm0, 0x150(%rsp)
vmovapd 0x150(%... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateSSEImpl.hpp |
void beagle::cpu::BeagleCPU4StateSSEImpl<double, 2, 0>::accumulateDerivativesDispatch2<true, true>(double*, double*, double*) | void BeagleCPU4StateSSEImpl<BEAGLE_CPU_4_SSE_DOUBLE>::accumulateDerivativesDispatch2(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
if (outSumSquaredDerivatives == NULL) {
accumulateDerivativesImpl<DoDerivatives, DoSum, false>(
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x90143
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x625c0
jmp 0x9015b
movq (%rsp), %rdi
movq 0x18(%rsp),... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateSSEImpl.hpp |
void beagle::cpu::BeagleCPU4StateSSEImpl<double, 2, 0>::accumulateDerivativesImpl<true, false, true>(double*, double*, double*) | void BeagleCPU4StateSSEImpl<BEAGLE_CPU_4_SSE_DOUBLE>::accumulateDerivativesImpl(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
V_Real vSum = VEC_SETZERO();
V_Real vSumSquared = VEC_SETZERO();
int k = 0;
for (; k < kPatternCount - 1; k +=... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, -0x80(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0xf0(%rsp)
vmovapd 0xf0(%rsp), %xmm1
vmovapd %xmm1, (%rsp)
vmovapd %xmm0, 0xe0(%rsp)
vmovapd 0xe0(%rsp)... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPU4StateSSEImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 1, 1>::calcStatesStatesFixedScaling(double*, int const*, double const*, int const*, double const*, double const*, int, int) | BEAGLE_CPU_TEMPLATE
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::calcStatesStatesFixedScaling(REALTYPE* destP,
const int* child1States,
const REALTYPE* child1TransMat,
... | movl 0x18(%rsp), %eax
movl 0x10(%rsp), %eax
movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x60(%rsp)
movl $0x0, -0x34(%rsp)
movq -0x60(%rsp), %rcx
movl -0x34(%rsp), %eax
cmpl 0... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 1, 1>::calcStatesPartialsFixedScaling(double*, int const*, double const*, double const*, double const*, double const*, int, int) | BEAGLE_CPU_TEMPLATE
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::calcStatesPartialsFixedScaling(REALTYPE* destP,
const int* states1,
const REALTYPE* matrices1,
... | subq $0x28, %rsp
movl 0x40(%rsp), %eax
movl 0x38(%rsp), %eax
movq 0x30(%rsp), %rax
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq %r9, -0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, -0x80(%rsp)
movl 0x24(%rax), %ecx
movl %ecx, -0xc(%rsp)
movl -0xc(%rsp), %ecx
a... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 1, 1>::calcPreStatesPartialsFixedScaling(double*, int const*, double const*, double const*, double const*, double const*, int, int) | BEAGLE_CPU_TEMPLATE
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::calcPreStatesPartialsFixedScaling(REALTYPE* destP,
const int* states1,
const REALTYPE* matrices1,
... | movl 0x18(%rsp), %eax
movl 0x10(%rsp), %eax
movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x8(%rsp), %rax
movl 0x24(%rax), %ecx
movl %ecx, -0x34(%rsp)
movl -0x34(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, -0x... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUSSEImpl<double, 1, 1>::calcPartialsPartialsAutoScaling(double*, double const*, double const*, double const*, double const*, int*) | BEAGLE_CPU_SSE_TEMPLATE
void BeagleCPUSSEImpl<BEAGLE_CPU_SSE_DOUBLE>::calcPartialsPartialsAutoScaling(double* destP,
const double* partials_q,
const double* matrices_q,
... | subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
movq 0x40(%rsp), %rax
m... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUSSEImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 1, 1>::~BeagleCPUImpl() | BEAGLE_CPU_TEMPLATE
BeagleCPUImpl<BEAGLE_CPU_GENERIC>::~BeagleCPUImpl() {
// free all that stuff...
// If you delete partials, make sure not to delete the last element
// which is TEMP_SCRATCH_PARTIAL twice.
for(unsigned int i=0; i<kEigenDecompCount; i++) {
if (gCategoryWeights[i] != NULL)
... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5ffe0
movq 0x8(%rsp), %rdi
callq 0x61b60
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUImpl<double, 1, 1>::calcStatesPartials(double*, int const*, double const*, double const*, double const*, int, int) | BEAGLE_CPU_TEMPLATE
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::calcStatesPartials(REALTYPE* destP,
const int* states1,
const REALTYPE* matrices1,
... | subq $0x18, %rsp
movl 0x28(%rsp), %eax
movl 0x20(%rsp), %eax
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq %rcx, -0x8(%rsp)
movq %r8, -0x10(%rsp)
movq %r9, -0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, -0x80(%rsp)
movl 0x24(%rax), %ecx
movl %ecx, -0x1c(%rsp)
movl -0x1c(%rsp), %ecx
addl $0x1, %ecx
mov... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::EigenDecompositionSquare<double, 1>::~EigenDecompositionSquare() | BEAGLE_CPU_EIGEN_TEMPLATE
EigenDecompositionSquare<BEAGLE_CPU_EIGEN_GENERIC>::~EigenDecompositionSquare() {
for(int i=0; i<kEigenDecompCount; i++) {
free(gEMatrices[i]);
free(gIMatrices[i]);
free(gEigenValues[i]);
}
free(gEMatrices);
free(gIMatrices);
free(gEigenValues);
free(matrixTmp);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x61070
movq 0x8(%rsp), %rdi
callq 0x61b60
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/EigenDecompositionSquare.hpp |
beagle::cpu::EigenDecompositionCube<double, 1>::~EigenDecompositionCube() | BEAGLE_CPU_EIGEN_TEMPLATE
EigenDecompositionCube<BEAGLE_CPU_EIGEN_GENERIC>::~EigenDecompositionCube() {
for(int i=0; i<kEigenDecompCount; i++) {
free(gCMatrices[i]);
free(gEigenValues[i]);
}
free(gCMatrices);
free(gEigenValues);
free(matrixTmp);
free(firstDerivTmp);
free(secondDerivTmp);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x1f987(%rip), %rcx # 0xcdf40
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x14(%rcx), %eax
jge 0xae60e
movq (%rsp), %rax
movq 0x40(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/EigenDecompositionCube.hpp |
beagle::cpu::EigenDecompositionCube<double, 1>::updateTransitionMatrices(int, int const*, int const*, int const*, double const*, double const*, double**, int) | BEAGLE_CPU_EIGEN_TEMPLATE
void EigenDecompositionCube<BEAGLE_CPU_EIGEN_GENERIC>::updateTransitionMatrices(int eigenIndex,
const int* probabilityIndices,
const int* firstDerivativeIndices,
... | subq $0x128, %rsp # imm = 0x128
movl 0x140(%rsp), %eax
movq 0x138(%rsp), %rax
movq 0x130(%rsp), %rax
movq %rdi, 0x120(%rsp)
movl %esi, 0x11c(%rsp)
movq %rdx, 0x110(%rsp)
movq %rcx, 0x108(%rsp)
movq %r8, 0x100(%rsp)
movq %r9, 0xf8(%rsp)
movq 0x120(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rax), %eax
movl $0x4,... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/EigenDecompositionCube.hpp |
beagle::cpu::BeagleCPUImpl<double, 1, 1>::threadWaiting(beagle::cpu::BeagleCPUImpl<double, 1, 1>::threadData*) | BEAGLE_CPU_TEMPLATE
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::threadWaiting(threadData* tData)
{
std::unique_lock<std::mutex> l(tData->m, std::defer_lock);
while (true)
{
l.lock();
// Wait until the queue won't be empty or stop is signaled
tData->cv.wait(l, [tData] () {
re... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rsi
addq $0x88, %rsi
leaq 0x38(%rsp), %rdi
callq 0x64bd0
jmp 0xb01f6
leaq 0x38(%rsp), %rdi
callq 0x62550
jmp 0xb0202
movq 0x48(%rsp), %rax
movq %rax, %rdi
addq $0x58, %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
leaq 0x38(%rsp), %rsi
cal... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 1, 1>::accumulateDerivativesDispatch1<false>(double*, double*, double*) | BEAGLE_CPU_TEMPLATE template <bool DoDerivatives>
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesDispatch1(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
if (outSumDerivatives == NULL) {
accumulateDerivativesDispatch2<DoDerivati... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xb0923
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x63670
jmp 0xb093b
movq (%rsp), %rdi
movq 0x18(%rsp)... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 1, 1>::accumulateDerivativesDispatch1<true>(double*, double*, double*) | BEAGLE_CPU_TEMPLATE template <bool DoDerivatives>
void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesDispatch1(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
if (outSumDerivatives == NULL) {
accumulateDerivativesDispatch2<DoDerivati... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xb0983
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x627a0
jmp 0xb099b
movq (%rsp), %rdi
movq 0x18(%rsp)... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 1, 1>::accumulateDerivativesDispatch2<false, false>(double*, double*, double*) | void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesDispatch2(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
if (outSumSquaredDerivatives == NULL) {
accumulateDerivativesImpl<DoDerivatives, DoSum, false>(
outDerivativ... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xb09e3
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x60a90
jmp 0xb09fb
movq (%rsp), %rdi
movq 0x18(%rsp),... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 1, 1>::accumulateDerivativesDispatch2<false, true>(double*, double*, double*) | void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesDispatch2(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
if (outSumSquaredDerivatives == NULL) {
accumulateDerivativesImpl<DoDerivatives, DoSum, false>(
outDerivativ... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xb0a43
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x632d0
jmp 0xb0a5b
movq (%rsp), %rdi
movq 0x18(%rsp),... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 1, 1>::accumulateDerivativesImpl<false, false, false>(double*, double*, double*) | void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesImpl(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
REALTYPE sum = 0.0;
REALTYPE sumSquared = 0.0;
for (int k = 0; k < kPatternCount; k++) {
REALTYPE derivative = grandNume... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x48(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x28(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
movq -0x48(%rsp), %rcx
movl -0x34(%rsp), %eax
cmpl 0x14(%... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 1, 1>::accumulateDerivativesImpl<false, false, true>(double*, double*, double*) | void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesImpl(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
REALTYPE sum = 0.0;
REALTYPE sumSquared = 0.0;
for (int k = 0; k < kPatternCount; k++) {
REALTYPE derivative = grandNume... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x48(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x28(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
movq -0x48(%rsp), %rcx
movl -0x34(%rsp), %eax
cmpl 0x14(%... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 1, 1>::accumulateDerivativesImpl<false, true, false>(double*, double*, double*) | void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesImpl(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
REALTYPE sum = 0.0;
REALTYPE sumSquared = 0.0;
for (int k = 0; k < kPatternCount; k++) {
REALTYPE derivative = grandNume... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x48(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x28(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
movq -0x48(%rsp), %rcx
movl -0x34(%rsp), %eax
cmpl 0x14(%... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 1, 1>::accumulateDerivativesDispatch2<true, true>(double*, double*, double*) | void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesDispatch2(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
if (outSumSquaredDerivatives == NULL) {
accumulateDerivativesImpl<DoDerivatives, DoSum, false>(
outDerivativ... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xb0e13
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x61b90
jmp 0xb0e2b
movq (%rsp), %rdi
movq 0x18(%rsp),... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 1, 1>::accumulateDerivativesImpl<true, false, false>(double*, double*, double*) | void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesImpl(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
REALTYPE sum = 0.0;
REALTYPE sumSquared = 0.0;
for (int k = 0; k < kPatternCount; k++) {
REALTYPE derivative = grandNume... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x48(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x28(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
movq -0x48(%rsp), %rcx
movl -0x34(%rsp), %eax
cmpl 0x14(%... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 1, 1>::accumulateDerivativesImpl<true, true, false>(double*, double*, double*) | void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesImpl(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
REALTYPE sum = 0.0;
REALTYPE sumSquared = 0.0;
for (int k = 0; k < kPatternCount; k++) {
REALTYPE derivative = grandNume... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x48(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x28(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
movq -0x48(%rsp), %rcx
movl -0x34(%rsp), %eax
cmpl 0x14(%... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
void beagle::cpu::BeagleCPUImpl<double, 1, 1>::accumulateDerivativesImpl<true, true, true>(double*, double*, double*) | void BeagleCPUImpl<BEAGLE_CPU_GENERIC>::accumulateDerivativesImpl(
double* outDerivatives,
double* outSumDerivatives,
double* outSumSquaredDerivatives) {
REALTYPE sum = 0.0;
REALTYPE sumSquared = 0.0;
for (int k = 0; k < kPatternCount; k++) {
REALTYPE derivative = grandNume... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x48(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x28(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
movq -0x48(%rsp), %rcx
movl -0x34(%rsp), %eax
cmpl 0x14(%... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUImpl.hpp |
beagle::cpu::BeagleCPUSSEImpl<double, 2, 0>::calcStatesStates(double*, int const*, double const*, int const*, double const*, int, int) | BEAGLE_CPU_SSE_TEMPLATE
void BeagleCPUSSEImpl<BEAGLE_CPU_SSE_DOUBLE>::calcStatesStates(double* destP,
const int* states_q,
const double* matrices_q,
... | subq $0x48, %rsp
movl 0x58(%rsp), %eax
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)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUSSEImpl.hpp |
beagle::cpu::BeagleCPUSSEImpl<double, 2, 0>::calcEdgeLogLikelihoods(int, int, int, int, int, int, double*) | BEAGLE_CPU_SSE_TEMPLATE
int BeagleCPUSSEImpl<BEAGLE_CPU_SSE_DOUBLE>::calcEdgeLogLikelihoods(const int parIndex,
const int childIndex,
const int probIndex,
... | subq $0x38, %rsp
movq 0x48(%rsp), %rax
movl 0x40(%rsp), %eax
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x24(%rsp), %ecx
movl 0x20(%rsp), %r8d
movl 0x1c(%rsp), ... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUSSEImpl.hpp |
beagle::cpu::BeagleCPUSSEImpl<double, 2, 0>::calcPartialsPartialsFixedScaling(double*, double const*, double const*, double const*, double const*, double const*, int, int) | BEAGLE_CPU_SSE_TEMPLATE
void BeagleCPUSSEImpl<BEAGLE_CPU_SSE_DOUBLE>::calcPartialsPartialsFixedScaling(double* __restrict destP,
const double* __restrict partials1,
... | subq $0x198, %rsp # imm = 0x198
movl 0x1b0(%rsp), %eax
movl 0x1a8(%rsp), %eax
movq 0x1a0(%rsp), %rax
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq %r8, -0x8(%rsp)
movq %r9, -0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, -0x80(%rsp)
movl 0x2c(%rax), %eax
subl $0x1, %eax... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUSSEImpl.hpp |
beagle::cpu::BeagleCPUSSEImpl<double, 2, 0>::calcPartialsPartialsAutoScaling(double*, double const*, double const*, double const*, double const*, int*) | BEAGLE_CPU_SSE_TEMPLATE
void BeagleCPUSSEImpl<BEAGLE_CPU_SSE_DOUBLE>::calcPartialsPartialsAutoScaling(double* destP,
const double* partials_q,
const double* matrices_q,
... | subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
movq 0x40(%rsp), %rax
m... | /beagle-dev[P]beagle-lib/libhmsbeagle/CPU/BeagleCPUSSEImpl.hpp |
Sequence::process_itemset(std::shared_ptr<Itemset>, unsigned int, int) | void Sequence::process_itemset(Itemset_S iset, unsigned int templ, int iter) {
if (iter > numLargeItemset->size()) return;
ostringstream &logger = env.logger;
ostringstream &seqstrm = env.seqstrm;
int i, it2;
int lsup, esup;
unsigned int ntpl;
Itemset_S iset2, ejoin, ljoin;
int it = (*... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebp
movq %rcx, 0x28(%rsp)
movslq %ecx, %rax
movq 0x98(%rdi), %rcx
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jb 0x12946
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq %rax, 0x68(%rsp)
xorps... | /fzyukio[P]cspade-full/Sequence.cc |
ncnn::fastMalloc(unsigned long) | static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x156d4
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
| /tongxiaobin[P]ncnn/benchmark/../src/allocator.h |
ncnn::fastFree(void*) | static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];... | pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x156f5
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
| /tongxiaobin[P]ncnn/benchmark/../src/allocator.h |
ncnn::BenchNet::~BenchNet() | int load_model()
{
// load file
int ret = 0;
Option opt;
opt.vulkan_compute = use_vulkan_compute;
ModelBinFromEmpty mb;
for (size_t i=0; i<layers.size(); i++)
{
Layer* layer = layers[i];
int lret = layer->load_model(mb);
... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x284f0
popq %rax
retq
| /tongxiaobin[P]ncnn/benchmark/benchncnn.cpp |
ncnn::Mat::create(int, unsigned long, ncnn::Allocator*) | inline void Mat::create(int _w, size_t _elemsize, Allocator* _allocator)
{
if (dims == 1 && w == _w && elemsize == _elemsize && packing == 1 && allocator == _allocator)
return;
release();
elemsize = _elemsize;
packing = 1;
allocator = _allocator;
dims = 1;
w = _w;
h = 1;
c... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x1, 0x28(%rax)
jne 0x15bc5
movq 0x8(%rsp), %rax
movl 0x2c(%rax), %eax
cmpl 0x2c(%rsp), %eax
jne 0x15bc5
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x20(%rsp), %... | /tongxiaobin[P]ncnn/benchmark/../src/mat.h |
ncnn::Mat::create(int, int, int, unsigned long, ncnn::Allocator*) | inline void Mat::create(int _w, int _h, int _c, size_t _elemsize, Allocator* _allocator)
{
if (dims == 3 && w == _w && h == _h && c == _c && elemsize == _elemsize && packing == 1 && allocator == _allocator)
return;
release();
elemsize = _elemsize;
packing = 1;
allocator = _allocator;
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x3, 0x28(%rax)
jne 0x16062
movq (%rsp), %rax
movl 0x2c(%rax), %eax
cmpl 0x2c(%rsp), %eax
jne 0x16062
movq (%rsp), %rax
movl 0x... | /tongxiaobin[P]ncnn/benchmark/../src/mat.h |
ncnn::PoolAllocator::~PoolAllocator() | PoolAllocator::~PoolAllocator()
{
clear();
if (!payouts.empty())
{
fprintf(stderr, "FATAL ERROR! pool allocator destroyed too early\n");
std::list< std::pair<size_t, void*> >::iterator it = payouts.begin();
for (; it != payouts.end(); it++)
{
void* ptr = it->seco... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0xa3026(%rip), %rax # 0xb9280
movq %rax, (%rdi)
callq 0x16370
jmp 0x16264
movq 0x8(%rsp), %rdi
addq $0x78, %rdi
callq 0x16ec0
testb $0x1, %al
jne 0x16312
movq 0xa9d5f(%rip), %rax # 0xbffe0
movq (%rax), %rdi
leaq 0x87fa1(%rip)... | /tongxiaobin[P]ncnn/src/allocator.cpp |
ncnn::PoolAllocator::clear() | void PoolAllocator::clear()
{
budgets_lock.lock();
std::list< std::pair<size_t, void*> >::iterator it = budgets.begin();
for (; it != budgets.end(); it++)
{
void* ptr = it->second;
ncnn::fastFree(ptr);
}
budgets.clear();
budgets_lock.unlock();
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
callq 0x16fc0
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x16ee0
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x16f30
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x16f10
te... | /tongxiaobin[P]ncnn/src/allocator.cpp |
ncnn::PoolAllocator::~PoolAllocator() | PoolAllocator::~PoolAllocator()
{
clear();
if (!payouts.empty())
{
fprintf(stderr, "FATAL ERROR! pool allocator destroyed too early\n");
std::list< std::pair<size_t, void*> >::iterator it = payouts.begin();
for (; it != payouts.end(); it++)
{
void* ptr = it->seco... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x16240
movq 0x8(%rsp), %rdi
movl $0x90, %esi
callq 0x14220
addq $0x18, %rsp
retq
nopl (%rax)
| /tongxiaobin[P]ncnn/src/allocator.cpp |
ncnn::fastFree(void*) | static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];... | pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x16465
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
| /tongxiaobin[P]ncnn/src/allocator.h |
ncnn::PoolAllocator::fastMalloc(unsigned long) | void* PoolAllocator::fastMalloc(size_t size)
{
budgets_lock.lock();
// find free budget
std::list< std::pair<size_t, void*> >::iterator it = budgets.begin();
for (; it != budgets.end(); it++)
{
size_t bs = it->first;
// size_compare_ratio ~ 100%
if (bs >= size && ((bs * siz... | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x8, %rdi
callq 0x16fc0
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
callq 0x16ee0
movq %rax, 0x78(%rsp)
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
callq 0x16f30
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rs... | /tongxiaobin[P]ncnn/src/allocator.cpp |
ncnn::fastMalloc(unsigned long) | static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x16744
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
| /tongxiaobin[P]ncnn/src/allocator.h |
ncnn::PoolAllocator::fastFree(void*) | void PoolAllocator::fastFree(void* ptr)
{
payouts_lock.lock();
// return to budgets
std::list< std::pair<size_t, void*> >::iterator it = payouts.begin();
for (; it != payouts.end(); it++)
{
if (it->second == ptr)
{
size_t size = it->first;
payouts.erase(it);... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x30, %rdi
callq 0x16fc0
movq 0x10(%rsp), %rdi
addq $0x78, %rdi
callq 0x16ee0
movq %rax, 0x50(%rsp)
movq 0x10(%rsp), %rdi
addq $0x78, %rdi
callq 0x16f30
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%r... | /tongxiaobin[P]ncnn/src/allocator.cpp |
ncnn::cpu_support_arm_neon() | int cpu_support_arm_neon()
{
#ifdef __ANDROID__
#if __aarch64__
return g_hwcaps & HWCAP_ASIMD;
#else
return g_hwcaps & HWCAP_NEON;
#endif
#elif __IOS__
#if __aarch64__
return g_hw_cputype == CPU_TYPE_ARM64;
#else
return g_hw_cputype == CPU_TYPE_ARM && g_hw_cpusubtype > CPU_SUBTYPE_ARM_V7;
#endif
#else
... | xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
| /tongxiaobin[P]ncnn/src/cpu.cpp |
ncnn::set_cpu_powersave(int) | int set_cpu_powersave(int powersave)
{
#ifdef __ANDROID__
static std::vector<int> sorted_cpuids;
static int little_cluster_offset = 0;
if (sorted_cpuids.empty())
{
// 0 ~ g_cpucount
sorted_cpuids.resize(g_cpucount);
for (int i=0; i<g_cpucount; i++)
{
sorted_c... | movl %edi, -0x4(%rsp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
nopw (%rax,%rax)
| /tongxiaobin[P]ncnn/src/cpu.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.