name string | code string | asm string | file string |
|---|---|---|---|
Network::Network(Network_param*) | Network::Network(Network_param* param) :
param(param)
{
clock = Clock::getInstance();
logger = Logging::getInstance();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
leaq 0x20(%rdi), %r15
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
callq 0x18178
movq %rax, 0x38(%rbx)
callq 0x181d8
movq %rax, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
... | /haukri[P]MasterProject/Network/Network.cpp |
Network::add(Synapse*) | void Network::add(Synapse* n_synapse) {
synapses.push_back(n_synapse);
if(!networkContainsPopulation(n_synapse->from_population))
populations.push_back(n_synapse->from_population);
if(!networkContainsPopulation(n_synapse->to_population))
populations.push_back(n_synapse->to_population);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xcbb6
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0xcbc1
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xced8
movq (%rsp), %rdx
movq 0x8(%rdx), %rax
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rcx
cmpq %... | /haukri[P]MasterProject/Network/Network.cpp |
Network::update() | void Network::update() {
for(Population* p : populations) {
p->update();
}
for(Synapse* s : synapses) {
s->update();
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %r15
cmpq %r15, %r14
je 0xce43
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x8, %r14
jmp 0xce30
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0xce5d
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x8... | /haukri[P]MasterProject/Network/Network.cpp |
Network::~Network() | Network::~Network()
{
} | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xcec1
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0xb2b0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xced6
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0xb2b0
popq %rbx
retq
| /haukri[P]MasterProject/Network/Network.cpp |
ANN::addLayer(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void ANN::addLayer(int size, string type) {
outputSize = size;
if(type.rfind("lowpass", 0) == 0 || type.rfind("highpass", 0) == 0 || type.rfind("passband", 0) == 0) {
layers.push_back(new Filter(inputSize, size, &learning_rate, type));
}
else {
layers.push_back(new Dense(inputSize, size,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0x34(%rdi)
leaq 0xd070(%rip), %rsi # 0x1a1f8
movl $0x7, %ecx
movq %rdx, %rdi
xorl %edx, %edx
callq 0xb330
testq %rax, %rax
je 0xd243
leaq 0xd059(%rip), %rsi # 0x1a200
m... | /haukri[P]MasterProject/Network/ANN/ANN.cpp |
ANN::fit(Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>) | void ANN::fit(Eigen::MatrixXd X, Eigen::MatrixXd y) {
// Calculate feed forward for X
Eigen::MatrixXd predicted = predict(X);
// Calculate error for output
Eigen::MatrixXd error = y - predicted;
error.transposeInPlace();
// Backpropagate error
for(int i = layers.size()-1; i > 0; i--) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rdi, %r14
leaq 0x70(%rsp), %r12
movq %r12, %rdi
callq 0xd744
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xd4d4
movq 0x70(%rsp), %rdi
callq 0xb300
movq %r15, 0x28(%rsp)
movq %rbx, 0x3... | /haukri[P]MasterProject/Network/ANN/ANN.cpp |
ANN::predict(Eigen::Matrix<double, -1, -1, 0, -1, -1>) | Eigen::MatrixXd ANN::predict(Eigen::MatrixXd input) {
for(auto layer : layers) {
input = layer->forward(input);
}
return input;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, (%rsp)
movq (%rsi), %rbp
movq 0x8(%rsi), %r14
cmpq %r14, %rbp
je 0xd557
leaq 0x20(%rsp), %r15
leaq 0x8(%rsp), %r12
movq (%rbp), %r13
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd744
movq (%r13), %rax
movq %r12, %rd... | /haukri[P]MasterProject/Network/ANN/ANN.cpp |
ANN::~ANN() | ANN::~ANN()
{
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xd5c1
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0xb2b0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xd5d6
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0xb2b0
popq %rbx
retq
| /haukri[P]MasterProject/Network/ANN/ANN.cpp |
Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::PlainObjectBase<Eigen::CwiseBinaryOp<Eigen::internal::scalar_difference_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Matrix<double, -1, -1, 0, -1, -1> const>>(Eigen::DenseBase<Eigen::CwiseBinaryOp<Eigen::internal::scalar_dif... | EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
: m_storage()
{
_check_template_params();
resizeLike(other);
_set_noalias(other);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq 0x8(%rax), %r8
movq 0x10(%rax), %rcx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %sil
orb %al, %sil
jne 0xd866
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFF... | /haukri[P]MasterProject/Eigen/src/Core/PlainObjectBase.h |
Eigen::DenseStorage<double, -1, -1, -1, 0>::resize(long, long, long) | EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
{
if(size != m_rows*m_cols)
{
internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
if (size)
m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
imulq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0xd99f
movq %rsi, %r12
movq (%r15), %rdi
callq 0xb300
testq %r12, %r12
je 0xd99a
movq %r12, %rax
shrq $0x3d, %rax
jne 0xd96c
leaq (,%r12,8), %rdi
callq 0x... | /haukri[P]MasterProject/Eigen/src/Core/DenseStorage.h |
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_difference_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Matrix<double, -1, -1, 0, -1, -1> const>, Eigen::internal::assign_op<double, double>>(Eigen::Matri... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq (%rax), %r12
movq (%rcx), %r13
movq 0x8(%rcx), %r15
movq 0x10(%rcx), %r14
cmpq %r15, 0x8(%rdi)
jne 0xd9ff
cmpq %r14, 0x10(%rbx)
je 0xda48
movq %r14, %rax
orq %r15, %rax
js 0xdada
testq %r15, %r15
sete %al
... | /haukri[P]MasterProject/Eigen/src/Core/AssignEvaluator.h |
Eigen::internal::inplace_transpose_selector<Eigen::Matrix<double, -1, -1, 0, -1, -1>, false, false>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1>&) | static void run(MatrixType& m) {
if (m.rows()==m.cols())
m.matrix().template triangularView<StrictlyUpper>().swap(m.matrix().transpose());
else
m = m.transpose().eval();
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
jne 0xdb56
leaq 0x10(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x28(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0xf(%rsp), %rdx
callq 0xdbb4
jmp 0xdb97
leaq 0x28(%rsp), %rsi
movq %rbx, (%rsi)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%... | /haukri[P]MasterProject/Eigen/src/Core/Transpose.h |
Eigen::internal::Assignment<Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 10u>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::swap_assign_op<double>, Eigen::internal::Dense2Triangular, void>::run(Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 10u>&, Eige... | EIGEN_DEVICE_FUNC
inline Scalar coeff(Index row, Index col) const { return derived().coeff(row,col); } | pushq %rbx
movq (%rsi), %rsi
movq (%rdi), %rdi
movq 0x8(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0xdc30
movq 0x8(%rsi), %rcx
movq 0x10(%rdi), %rdx
cmpq %rcx, %rdx
jne 0xdc30
testq %rdx, %rdx
jle 0xdc2e
movq (%rsi), %rsi
movq (%rdi), %rdi
shlq $0x3, %rcx
leaq (,%rax,8), %r8
xorl %r9d, %r9d
cmpq %r9, %rax
movq %r9, %r10
cmo... | /haukri[P]MasterProject/Eigen/src/Core/TriangularMatrix.h |
Eigen::DenseStorage<double, -1, -1, -1, 1>::resize(long, long, long) | EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
{
if(size != m_rows*m_cols)
{
internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
if (size)
m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
imulq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0xde1b
movq %rsi, %r12
movq (%r15), %rdi
callq 0xb300
testq %r12, %r12
je 0xde16
movq %r12, %rax
shrq $0x3d, %rax
jne 0xdde8
leaq (,%r12,8), %rdi
callq 0x... | /haukri[P]MasterProject/Eigen/src/Core/DenseStorage.h |
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 1, -1, -1>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Matrix<double, -1, -1, 1, -1, -1> const&, Eigen::internal::assign_op<double, double> const&) | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rsi), %r12
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rbx
cmpq %r15, 0x8(%rdi)
jne 0xde70
cmpq %rbx, 0x10(%r14)
je 0xdeb9
movq %r15, %rax
orq %rbx, %rax
js 0xdf3c
testq %r15, %r15
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0xdea4
movabsq... | /haukri[P]MasterProject/Eigen/src/Core/AssignEvaluator.h |
Dense::Dense(int, int, double*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | Dense::Dense(int input_size, int output_size, double* nlearning_rate, string ntype) {
weigths = Eigen::MatrixXd(input_size, output_size);
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
std::default_random_engine generator (seed);
std::normal_distribution<double> distributio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movl %edx, %r8d
leaq 0x178ea(%rip), %rax # 0x25898
movq %rax, (%rdi)
leaq 0x80(%rdi), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups... | /haukri[P]MasterProject/Network/ANN/Dense.cpp |
Dense::backward(Eigen::Matrix<double, -1, -1, 0, -1, -1>) | Eigen::MatrixXd Dense::backward(Eigen::MatrixXd grad_output) {
Eigen::MatrixXd delta;
if(type == "tanh") {
delta = grad_output.cwiseProduct(activation.unaryExpr(&activation_functions::tanh_transfer_derivative).transpose());
}
else if(type == "sigmoid") {
delta = grad_output.cwiseProduct(... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x70(%rsi), %r12
leaq 0xbc0d(%rip), %rsi # 0x1a058
movq %r12, %rdi
callq 0xb090
testl %eax, %eax
je 0xe4ba
leaq 0xcbaa(%rip)... | /haukri[P]MasterProject/Network/ANN/Dense.cpp |
Dense::~Dense() | Dense::~Dense() {
cout << "Object deconstructed!" << endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x17054(%rip), %rax # 0x25898
movq %rax, (%rdi)
movq 0x17782(%rip), %r14 # 0x25fd0
leaq 0xc7bb(%rip), %rsi # 0x1b010
movl $0x15, %edx
movq %r14, %rdi
callq 0xb2e0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0xb280
movs... | /haukri[P]MasterProject/Network/ANN/Dense.cpp |
void Eigen::internal::call_assignment<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::Product<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0> const, Eigen::Replicate<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1,... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src)
{
call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0xed08
movq 0x10(%r14), %rax
movq %rax, 0x28(%r15)
movq (%rax), %rcx
movq %rcx, 0x30(%r15)
movupd 0x8(%rax), %xmm0
movlpd %xmm0, 0x38(%r15)
movupd %xmm0, 0x40(%r... | /haukri[P]MasterProject/Eigen/src/Core/AssignEvaluator.h |
void Eigen::internal::evaluateProductBlockingSizesHeuristic<double, double, 1, long>(long&, long&, long&, long) | void evaluateProductBlockingSizesHeuristic(Index& k, Index& m, Index& n, Index num_threads = 1)
{
typedef gebp_traits<LhsScalar,RhsScalar> Traits;
// Explanations:
// Let's recall that the product algorithms form mc x kc vertical panels A' on the lhs and
// kc x nc blocks B' on the rhs. B' has to fit into L2/L... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movb 0x16c06(%rip), %al # 0x26280
testb %al, %al
je 0xf96f
movq 0x16bdf(%rip), %rsi # 0x26268
movq 0x16be0(%rip), %r11 # 0x26270
movq 0x16be1(%rip), %rcx # 0x26278
movq (%r15), %rdi
cm... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
Eigen::internal::CacheSizes::CacheSizes() | CacheSizes(): m_l1(-1),m_l2(-1),m_l3(-1) {
int l1CacheSize, l2CacheSize, l3CacheSize;
queryCacheSizes(l1CacheSize, l2CacheSize, l3CacheSize);
m_l1 = manage_caching_sizes_helper(l1CacheSize, defaultL1CacheSize);
m_l2 = manage_caching_sizes_helper(l2CacheSize, defaultL2CacheSize);
m_l3 = manage_cachin... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, (%rdi)
movq $-0x1, 0x10(%rdi)
leaq 0x14(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xfa3b
movl (%r14), %eax
testl %eax, %eax
movl $0x8000, %ec... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
Eigen::internal::queryCacheSizes(int&, int&, int&) | inline void queryCacheSizes(int& l1, int& l2, int& l3)
{
#ifdef EIGEN_CPUID
int abcd[4];
const int GenuineIntel[] = {0x756e6547, 0x49656e69, 0x6c65746e};
const int AuthenticAMD[] = {0x68747541, 0x69746e65, 0x444d4163};
const int AMDisbetter_[] = {0x69444d41, 0x74656273, 0x21726574}; // "AMDisbetter!"
// id... | pushq %rbx
movq %rdx, %r8
xorl %r9d, %r9d
xorl %eax, %eax
xorl %ecx, %ecx
xchgq %rbx, %r10
cpuid
xchgq %rbx, %r10
movl %r10d, %eax
xorl $0x756e6547, %eax # imm = 0x756E6547
movl %edx, %r11d
xorl $0x49656e69, %r11d # imm = 0x49656E69
orl %eax, %r11d
movl %ecx, %eax
xorl $0x6c65746e, %eax # imm = 0x6C657... | /haukri[P]MasterProject/Eigen/src/Core/util/Memory.h |
Eigen::internal::queryCacheSizes_intel_codes(int&, int&, int&) | inline void queryCacheSizes_intel_codes(int& l1, int& l2, int& l3)
{
int abcd[4];
abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
l1 = l2 = l3 = 0;
EIGEN_CPUID(abcd,0x00000002,0);
unsigned char * bytes = reinterpret_cast<unsigned char *>(abcd)+2;
bool check_for_p2_core2 = false;
for(int i=0; i<14; ++i)
{
... | movq %rdx, %r8
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %r9d, %r9d
movl %r9d, (%rdx)
movl %r9d, (%rsi)
movl %r9d, (%rdi)
movl $0x2, %eax
xorl %ecx, %ecx
xchgq %rbx, %r10
cpuid
xchgq %rbx, %r10
movl %eax, -0x18(%rsp)
movl %r10d, -0x14(%rsp)
movl %ecx, -0x10(%rsp)
movl %edx, -0xc(%rsp)
movl $0x2, %eax
leaq 0xb17... | /haukri[P]MasterProject/Eigen/src/Core/util/Memory.h |
Eigen::internal::gemm_functor<double, long, Eigen::internal::general_matrix_matrix_product<long, double, 0, false, double, 0, false, 0>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::internal::gemm_blocking_space<0, double, double, -... | void operator() (Index row, Index rows, Index col=0, Index cols=-1, GemmParallelInfo<Index>* info=0) const
{
if(cols==-1)
cols = m_rhs.cols();
Gemm::run(rows, cols, m_lhs.cols(),
&m_lhs.coeffRef(row,0), m_lhs.outerStride(),
&m_rhs.coeffRef(0,col), m_rhs.outerStride(),
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rax
movq %r8, %r14
movq %rdx, %r11
movq %rdi, %r10
cmpq $-0x1, %r8
jne 0xfddf
movq 0x8(%r10), %rdx
movq 0x10(%rdx), %r14
movq (%r10), %rdi
movq 0x8(%r10), %r12
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %rdx
leaq (,%rsi,8), %rbx
addq (%rdi), %rbx
movq 0x8(%r12... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralMatrixMatrix.h |
Eigen::internal::general_matrix_matrix_product<long, double, 0, false, double, 0, false, 0>::run(long, long, long, double const*, long, double const*, long, double*, long, double, Eigen::internal::level3_blocking<double, double>&, Eigen::internal::GemmParallelInfo<long>*) | static void run(Index rows, Index cols, Index depth,
const LhsScalar* _lhs, Index lhsStride,
const RhsScalar* _rhs, Index rhsStride,
ResScalar* _res, Index resStride,
ResScalar alpha,
level3_blocking<LhsScalar,RhsScalar>& blocking,
GemmParallelInfo<Index>* info = 0)
{
typedef const_blas_data_mapper<LhsSca... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movsd %xmm0, -0x120(%rbp)
movq %r9, -0xd0(%rbp)
movq %r8, -0xf8(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, %r13
movq 0x28(%rbp), %rbx
movq 0x20(%rbx), %rdx
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %r12
cmpq %rdi, %r15
movq %rd... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralMatrixMatrix.h |
Eigen::internal::gemm_pack_lhs<double, long, Eigen::internal::const_blas_data_mapper<double, long, 0>, 4, 2, 0, false, false>::operator()(double*, Eigen::internal::const_blas_data_mapper<double, long, 0> const&, long, long, long, long) | EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, ColMajor, Conjugate, PanelMode>
::operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
{
typedef typename packet_traits<Scalar>::type Packet;
enum { PacketSize = packet_traits<Scalar>::s... | pushq %r14
pushq %rbx
pushq %rax
orq 0x20(%rsp), %r9
jne 0x104bb
leaq 0x3(%r8), %r10
testq %r8, %r8
cmovnsq %r8, %r10
movq %r8, %r9
shrq $0x3f, %r9
addq %r8, %r9
andq $-0x2, %r9
cmpq $0x4, %r8
jl 0x10435
andq $-0x4, %r10
xorl %eax, %eax
xorl %edi, %edi
testq %rcx, %rcx
jle 0x1042a
movq %rax, %r11
orq $0x2, %r11
xorl %e... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::CwiseUnaryOp<double (*)(double), Eigen::Matrix<double, -1, -1, 0, -1, -1> const>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::CwiseUnaryOp<double (*)(double), Eigen::Matrix... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %r12
movq (%rax), %r13
movq 0x8(%rax), %r15
movq 0x10(%rax), %r14
cmpq %r15, 0x8(%rdi)
jne 0x11add
cmpq %r14, 0x10(%rbx)
je 0x11b26
movq %r14, %rax
orq %r15, %rax
js 0x11b88
testq %r15, %r15
sete %al
testq %r14, %r1... | /haukri[P]MasterProject/Eigen/src/Core/AssignEvaluator.h |
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::internal::assign_op<double, double> const&) | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r12
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r14
cmpq %r15, 0x8(%rdi)
jne 0x11bf7
cmpq %r14, 0x10(%rbx)
je 0x11c40
movq %r14, %rax
orq %r15, %rax
js 0x11cc4
testq %r15, %r15
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x11c2b
mov... | /haukri[P]MasterProject/Eigen/src/Core/AssignEvaluator.h |
void Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::resizeLike<Eigen::Product<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0>>(Eigen::EigenBase<Eigen::Product<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0>> const&) | EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
{
const OtherDerived& other = _other.derived();
internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
const Index othersize = other.rows()*other.cols();
... | pushq %rax
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq 0x8(%rax), %r8
movq 0x10(%rcx), %rcx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %sil
orb %al, %sil
jne 0x11fea
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rcx
cmpq %r8, %rax
jl 0x1203a
movq %rcx, %rax
orq %r8, %rax
js 0x12... | /haukri[P]MasterProject/Eigen/src/Core/PlainObjectBase.h |
Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::PlainObjectBase<Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, 0>>(Eigen::DenseBase<Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::... | EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
: m_storage()
{
_check_template_params();
resizeLike(other);
_set_noalias(other);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x12156
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq 0x10(%rax), %r8
movq 0x8(%rcx), %rcx
cmpq %r8, 0x8(%rbx)
jne 0x120a0
cmpq %rcx, 0x10(%rbx)
je 0x120de
movq %rcx, %rax
orq %r8, %rax
js ... | /haukri[P]MasterProject/Eigen/src/Core/PlainObjectBase.h |
void Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::resizeLike<Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, 0>>(Eigen::EigenBase<Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::... | EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
{
const OtherDerived& other = _other.derived();
internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
const Index othersize = other.rows()*other.cols();
... | pushq %rax
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rax), %r8
movq 0x8(%rcx), %rcx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %sil
orb %al, %sil
jne 0x1218c
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rcx
cmpq %r8, %rax
jl 0x121dc
movq %rcx, %rax
orq %r8, %rax
js 0x12... | /haukri[P]MasterProject/Eigen/src/Core/PlainObjectBase.h |
void Eigen::internal::generic_product_impl<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::DenseShape, Eigen::DenseShape, 8>::evalTo<Eigen::Matrix<double, -1, -1, 0, -1, -1>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Transpose<Eigen:... | static void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
{
if((rhs.rows()+dst.rows()+dst.cols())<20 && rhs.rows()>0)
lazyproduct::evalTo(dst, lhs, rhs);
else
{
dst.setZero();
scaleAndAddTo(dst, lhs, rhs, Scalar(1));
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rax
movq 0x10(%rax), %rdx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
testq %rdx, %rdx
jle 0x12257
addq %rax, %rdx
addq %rcx, %rdx
cmpq $0x13, %rdx
jg 0x12257
movq %r15, %rdi
movq %r14, %rsi
movq %r... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralMatrixMatrix.h |
Eigen::internal::product_evaluator<Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, 1>, 8, Eigen::DenseShape, Eigen::DenseShape, double, double>::coeff(long, long) const | const CoeffReturnType coeff(Index row, Index col) const
{
return (m_lhs.row(row).transpose().cwiseProduct( m_rhs.col(col) )).sum();
} | pushq %rax
movq (%rdi), %rax
movq (%rax), %r8
movq 0x8(%rax), %r9
testq %r8, %r8
sete %al
testq %r9, %r9
setns %cl
orb %al, %cl
je 0x126fd
testq %rsi, %rsi
js 0x126c7
movq (%rdi), %rax
cmpq %rsi, 0x10(%rax)
jle 0x126c7
movq 0x8(%rdi), %rcx
movq (%rcx), %rax
movq 0x10(%rcx), %rcx
testq %rax, %rax
sete %r10b
testq %rcx, ... | /haukri[P]MasterProject/Eigen/src/Core/ProductEvaluators.h |
Eigen::internal::gemm_functor<double, long, Eigen::internal::general_matrix_matrix_product<long, double, 1, false, double, 1, false, 0>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1> const>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1> const>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::in... | void operator() (Index row, Index rows, Index col=0, Index cols=-1, GemmParallelInfo<Index>* info=0) const
{
if(cols==-1)
cols = m_rhs.cols();
Gemm::run(rows, cols, m_lhs.cols(),
&m_lhs.coeffRef(row,0), m_lhs.outerStride(),
&m_rhs.coeffRef(0,col), m_rhs.outerStride(),
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rax
movq %rdx, %rbx
movq %rdi, %r10
cmpq $-0x1, %r8
jne 0x12794
movq 0x8(%r10), %rdx
movq (%rdx), %rdx
movq 0x8(%rdx), %r8
movq (%r10), %rdx
movq 0x8(%r10), %rdi
movq (%rdx), %r9
movq 0x8(%r9), %rdx
movq %rdx, %r11
imulq %rsi, %r11
shlq $0x3, %r11
addq (... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralMatrixMatrix.h |
Eigen::internal::general_matrix_matrix_product<long, double, 1, false, double, 1, false, 0>::run(long, long, long, double const*, long, double const*, long, double*, long, double, Eigen::internal::level3_blocking<double, double>&, Eigen::internal::GemmParallelInfo<long>*) | static void run(Index rows, Index cols, Index depth,
const LhsScalar* _lhs, Index lhsStride,
const RhsScalar* _rhs, Index rhsStride,
ResScalar* _res, Index resStride,
ResScalar alpha,
level3_blocking<LhsScalar,RhsScalar>& blocking,
GemmParallelInfo<Index>* info = 0)
{
typedef const_blas_data_mapper<LhsSca... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movsd %xmm0, -0x120(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xd0(%rbp)
movq %rdx, %r13
movq 0x28(%rbp), %rbx
movq 0x20(%rbx), %rdx
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %r12
cmpq %rdi, %r15
movq %rd... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralMatrixMatrix.h |
Eigen::internal::gemm_pack_lhs<double, long, Eigen::internal::const_blas_data_mapper<double, long, 1>, 4, 2, 1, false, false>::operator()(double*, Eigen::internal::const_blas_data_mapper<double, long, 1> const&, long, long, long, long) | EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, RowMajor, Conjugate, PanelMode>
::operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
{
typedef typename packet_traits<Scalar>::type Packet;
enum { PacketSize = packet_traits<Scalar>::s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, 0x10(%rsp)
orq 0x100(%rsp), %r9
jne 0x13157
movq %rdx, %rdi
movq %rcx, %r13
shrq $0x3f, %r13
addq %rcx, %r13
andq $-0x2, %r13
leaq 0x18(%rsi), %rax
movq %rax, 0x78(%rsp)
movl $0x4, %edx
xorl %r9d, %r9d
xorl %r10d, %r10d
movq %r... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
Eigen::internal::gemm_pack_rhs<double, long, Eigen::internal::const_blas_data_mapper<double, long, 1>, 4, 1, false, false>::operator()(double*, Eigen::internal::const_blas_data_mapper<double, long, 1> const&, long, long, long, long) | EIGEN_DONT_INLINE void gemm_pack_rhs<Scalar, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
::operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
{
EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS ROWMAJOR");
EIGEN_UNUSED_VARIABLE(stride);
EIGEN_UNUSED_VARIABL... | pushq %r15
pushq %r14
pushq %rbx
orq 0x20(%rsp), %r9
jne 0x13257
leaq 0x3(%r8), %rax
testq %r8, %r8
cmovnsq %r8, %rax
movq %rax, %rdi
andq $-0x4, %rdi
cmpq $0x4, %r8
jl 0x1320a
movq (%rdx), %r10
movq 0x8(%rdx), %r11
addq $0x18, %r10
shlq $0x3, %r11
xorl %ebx, %ebx
xorl %r9d, %r9d
movq %r10, %r14
movq %rcx, %r15
testq %... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq (%rax), %r12
movq (%rcx), %r13
movsd 0x20(%rsi), %xmm2
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %r14
cmpq %r15, 0x8(%rdi)
jne 0x132ac
cmpq %r14, 0x10(%rbx)
je 0x132ff
movq %r14, %rax
orq %r1... | /haukri[P]MasterProject/Eigen/src/Core/AssignEvaluator.h |
Izhikevich::Izhikevich(long, int) | Izhikevich::Izhikevich(long n_populationID, int n_neuronID) : param(new Izhikevich_param) {
populationID = n_populationID;
neuronID = n_neuronID;
v = param->c;
u = 0.0;
initialize();
} | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x11c5c(%rip), %rax # 0x25a30
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movl $0x28, %edi
callq 0xb2a0
movaps 0x6221(%rip), %xmm0 # 0x1a010
movups %xmm0, (%rax)
movaps 0x6227(%rip), %xmm0 # 0x1a020
movup... | /haukri[P]MasterProject/Network/Neuron/Izhikevich.cpp |
Izhikevich::Izhikevich(long, int, Izhikevich_param*) | Izhikevich::Izhikevich(long n_populationID, int n_neuronID, Izhikevich_param* param) : param(param) {
populationID = n_populationID;
neuronID = n_neuronID;
v = param->c;
u = 0.0;
initialize();
} | pushq %rbx
movq %rdi, %rbx
leaq 0x11bef(%rip), %rax # 0x25a30
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x58(%rdi)
movq %rsi, 0x8(%rdi)
movl %edx, 0x10(%rdi)
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x28(%rdi)
movq $0x0, 0x20(%rdi)
callq 0x181d8
movq %rax, 0x18(%rbx)
popq %rbx
retq
nop
| /haukri[P]MasterProject/Network/Neuron/Izhikevich.cpp |
Izhikevich::update(double) | Event* Izhikevich::update(double n_dt) {
dt = n_dt;
dv = 0.04*v*v + 5*v + 140 - u + input_current;
du = param->a*(param->b*v - u);
v += dv * dt + input_spike;
u += du * dt;
v = ( v < -std::numeric_limits< double >::max() ? -std::numeric_limits< double >::max() : v );
logger->logValue... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd %xmm0, 0x50(%rdi)
movsd 0x28(%rdi), %xmm2
movsd 0xb82b(%rip), %xmm1 # 0x1f6b8
mulsd %xmm2, %xmm1
movsd 0xb827(%rip), %xmm3 # 0x1f6c0
mulsd %xmm2, %xmm3
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
addsd 0xb81b(%rip), %xmm1 # 0x1f6c8
movsd 0x20(%rdi), %xmm3
sub... | /haukri[P]MasterProject/Network/Neuron/Izhikevich.cpp |
CurrentGenerator::CurrentGenerator(CurrentGenerator_param*) | CurrentGenerator::CurrentGenerator(CurrentGenerator_param* param) : param(param) {
clock = Clock::getInstance();
initialize();
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
generator = std::default_random_engine(seed);
distribution = std::normal_distribution<double>(pa... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1197a(%rip), %rax # 0x25a80
movq %rax, (%rdi)
movq %rsi, 0x28(%rdi)
movq $0x1, 0x30(%rdi)
xorps %xmm0, %xmm0
movhps 0x6c81(%rip), %xmm0 # xmm0 = xmm0[0,1],mem[0,1]
movups %xmm0, 0x38(%rdi)
xorl %r15d, %r15d
movq %r15, 0x48(%rdi)
movb %r15b,... | /haukri[P]MasterProject/Network/Neuron/CurrentGenerator.cpp |
CurrentGenerator::update(double) | Event* CurrentGenerator::update(double n_dt) {
if(param->ac_hz > 0) {
return new CurrentEvent(param->I + sin(2*3.1415926535897*param->ac_hz*clock->getCurrentTime()) + distribution(generator)*param->noiseOn, 1.0);
}
return new CurrentEvent(param->I + distribution(generator)*param->noiseOn, 1.0);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq 0x28(%rdi), %r15
movsd 0x20(%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x28, %edi
callq 0xb2a0
movq %rax, %rbx
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movsd (%r15), %xmm0
movsd %xmm0, 0x10(%rsp)
jbe 0x1427a
movsd 0x20(%r15), %x... | /haukri[P]MasterProject/Network/Neuron/CurrentGenerator.cpp |
SignalGenerator::SignalGenerator(SignalGenerator_param*) | SignalGenerator::SignalGenerator(SignalGenerator_param* param) : param(param) {
clock = Clock::getInstance();
initialize();
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
generator = std::default_random_engine(0);
distribution = std::normal_distribution<double>(param->n... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x11725(%rip), %rax # 0x25b10
movq %rax, (%rdi)
movq %rsi, 0x28(%rdi)
movl $0x1, %r15d
movq %r15, 0x30(%rdi)
xorps %xmm0, %xmm0
movhps 0x699a(%rip), %xmm0 # xmm0 = xmm0[0,1],mem[0,1]
movups %xmm0, 0x38(%rdi)
xorl %r12d, ... | /haukri[P]MasterProject/Network/Neuron/SignalGenerator.cpp |
SignalGenerator::update(double) | Event* SignalGenerator::update(double n_dt) {
double signalValue = 0;
if(param->f1 > 0)
signalValue += sin(2*3.1415926535897*param->f1*clock->getCurrentTime());
if(param->f2 > 0)
signalValue += sin(2*3.1415926535897*param->f2*clock->getCurrentTime());
if(param->f3 > 0)
signalValu... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movsd (%rax), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
xorpd %xmm1, %xmm1
jbe 0x1449c
mulsd 0xb27a(%rip), %xmm2 # 0x1f6f0
movsd %xmm2, 0x8(%rsp)
movq 0x58(%rbx), %rdi
callq 0x181ae
mulsd 0x8(%rsp), %xmm0
callq 0xb060
xorpd %xmm1, %xmm... | /haukri[P]MasterProject/Network/Neuron/SignalGenerator.cpp |
PassThrough::update(double) | Event* PassThrough::update(double n_dt) {
if(eventType == EventType::Spike) {
return new SpikeEvent(multiplicity, weight);
}
else {
return new NoEvent();
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x0, 0x30(%rdi)
je 0x147c6
movl $0x18, %edi
callq 0xb2a0
movq %rax, %rbx
movl $0x2, 0x8(%rax)
leaq 0x11241(%rip), %rax # 0x259f0
movq %rax, (%rbx)
callq 0x18178
movq %rax, %rdi
callq 0x181ae
movsd %xmm0, 0x10(%rbx)
jmp 0x1482c
movq %rdi, %r14
movl $0x28, %edi
... | /haukri[P]MasterProject/Network/Neuron/PassThrough.cpp |
PassThrough::handleEvent(Event*) | void PassThrough::handleEvent(Event* e) {
if(e->type == EventType::Spike) {
eventType = EventType::Spike;
multiplicity = static_cast<SpikeEvent*>(e)->multiplicity;
weight = static_cast<SpikeEvent*>(e)->weight;
}
else {
eventType = EventType::No;
}
} | cmpl $0x0, 0x8(%rsi)
je 0x1486a
movl $0x2, 0x30(%rdi)
retq
movl $0x0, 0x30(%rdi)
movl 0x18(%rsi), %eax
movl %eax, 0x40(%rdi)
movsd 0x20(%rsi), %xmm0
movsd %xmm0, 0x38(%rdi)
retq
| /haukri[P]MasterProject/Network/Neuron/PassThrough.cpp |
iaf_psc_alpha::iaf_psc_alpha(long, int) | iaf_psc_alpha::iaf_psc_alpha(long n_populationID, int n_neuronID) : param(new iaf_psc_alpha_param) {
populationID = n_populationID;
neuronID = n_neuronID;
initialize();
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1134d(%rip), %rax # 0x25bf0
movq %rax, (%rdi)
movb $0x1, 0x20(%rdi)
movl $0x50, %edi
callq 0xb2a0
movaps 0xae95(%rip), %xmm0 # 0x1f750
movups %xmm0, (%rax)
movaps 0xae9b(%rip), %xmm0 # 0x1f760
movups %xmm0, 0x10(%rax)
xo... | /haukri[P]MasterProject/Network/Neuron/iaf_psc_alpha.cpp |
binary_fuse8_hash_batch(unsigned long, binary_fuse8_s const*) | static inline binary_hashes_t binary_fuse8_hash_batch(uint64_t hash,
const binary_fuse8_t *filter) {
uint64_t hi = binary_fuse_mulhi(hash, filter->SegmentCountLength);
binary_hashes_t ans;
ans.h0 = (uint32_t)hi;
ans.h1 = ans.h0 + filter->SegmentLength;
ans.h2 = ans.h1 +... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, %esi
callq 0x2530
movq %rax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
addl %ecx, %eax
movl %eax, 0x30(%... | /FastFilter[P]FilterPassword/dependencies/xor_singleheader/include/binaryfusefilter.h |
sha1::SHA1::reset() | SHA1 &reset() {
m_digest[0] = 0x67452301;
m_digest[1] = 0xEFCDAB89;
m_digest[2] = 0x98BADCFE;
m_digest[3] = 0x10325476;
m_digest[4] = 0xC3D2E1F0;
m_blockByteIndex = 0;
m_byteCount = 0;
return *this;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x67452301, 0x8(%rax) # imm = 0x67452301
movl $0xefcdab89, 0xc(%rax) # imm = 0xEFCDAB89
movl $0x98badcfe, 0x10(%rax) # imm = 0x98BADCFE
movl $0x10325476, 0x14(%rax) # imm = 0x10325476
movl $0xc3d2e1f0, 0x18(%rax) # imm = 0xC3D2E1F0
movq $0x0, 0x60(%rax)
movq $0x0, 0x6... | /FastFilter[P]FilterPassword/src/sha.h |
sha1::SHA1::processByte(unsigned char) | SHA1 &processByte(uint8_t octet) {
this->m_block[this->m_blockByteIndex++] = octet;
++this->m_byteCount;
if (m_blockByteIndex == 64) {
this->m_blockByteIndex = 0;
processBlock();
}
return *this;
} | subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb 0xf(%rsp), %dl
movq 0x60(%rax), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x60(%rax)
movb %dl, 0x1c(%rax,%rcx)
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
cmpq $0x40, 0x60(%rax)
j... | /FastFilter[P]FilterPassword/src/sha.h |
MixSplit::murmur64(unsigned long) | inline static uint64_t murmur64(uint64_t h) {
h ^= h >> 33;
h *= UINT64_C(0xff51afd7ed558ccd);
h ^= h >> 33;
h *= UINT64_C(0xc4ceb9fe1a85ec53);
h ^= h >> 33;
return h;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x21, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movabsq $-0xae502812aa7333, %rax # imm = 0xFF51AFD7ED558CCD
imulq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x21, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movabsq $-0x3b314601e57a13a... | /FastFilter[P]FilterPassword/src/util.h |
llvm::dwarf::toString(std::optional<llvm::DWARFFormValue> const&) | inline std::optional<const char *>
toString(const std::optional<DWARFFormValue> &V) {
if (!V)
return std::nullopt;
Expected<const char*> E = V->getAsCString();
if (!E) {
consumeError(E.takeError());
return std::nullopt;
}
return *E;
} | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xb2330
testb $0x1, %al
jne 0xb24a6
leaq 0x38(%rsp), %rdi
callq 0xb86f0
jmp 0xb252b
movq 0x30(%rsp), %rdi
callq 0xb8710
movq %rax, %rsi
leaq 0x18(%rsp), %rdi
callq 0x274f30
leaq 0x18(%rsp), %rdi
callq 0xb8720
testb $0x1, %al
jne 0xb2502
leaq 0x10(%rsp),... | /llvm/DebugInfo/DWARF/DWARFFormValue.h |
llvm::DenseMapIterator<llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)1, false>> const*, llvm::ArrayRef<llvm::support::detail::packed_endian_specific_integral<unsigned int, (llvm::endianness)1, 1ul, 1ul>>, llvm::DenseMapInfo<llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)1, fal... | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEm... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x955d0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
mo... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::ELFDumper<llvm::object::ELFType<(llvm::endianness)1, false>>::dumpRelocSection(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)1, false>> const*) | Expected<ELFYAML::RelocationSection *>
ELFDumper<ELFT>::dumpRelocSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::RelocationSection>();
if (auto E = dumpCommonRelocationSection(Shdr, *S))
return std::move(E);
auto SymTabOrErr = Obj.getSection(Shdr->sh_link);
if (!SymTabOrErr)
return S... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq 0x248(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x238(%rsp), %rdi
callq 0xf5660
movq 0x240(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x238(%rsp), %rd... | /obj2yaml/elf2yaml.cpp |
(anonymous namespace)::ELFDumper<llvm::object::ELFType<(llvm::endianness)0, false>>::dumpRelrSection(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, false>> const*) | Expected<ELFYAML::RelrSection *>
ELFDumper<ELFT>::dumpRelrSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::RelrSection>();
if (auto E = dumpCommonSection(Shdr, *S))
return std::move(E);
if (Expected<ArrayRef<Elf_Relr>> Relrs = Obj.relrs(*Shdr)) {
S->Entries.emplace();
for (Elf_Relr ... | subq $0xc8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0xfb260
movq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0xfb2b0
movq 0x18(%rsp), %... | /obj2yaml/elf2yaml.cpp |
llvm::DenseMap<llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, true>> const*, llvm::ArrayRef<llvm::support::detail::packed_endian_specific_integral<unsigned int, (llvm::endianness)0, 1ul, 1ul>>, llvm::DenseMapInfo<llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, true>> const... | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rax), %ecx
movl %ecx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x40, 0xc(%rsp)
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x94600
movl %eax, 0x8(%rsp)
leaq 0xc... | /llvm/ADT/DenseMap.h |
llvm::DWARFContext::DWARFContextState::parseMacroOrMacinfo(llvm::DWARFContext::DWARFContextState::MacroSecType) | std::unique_ptr<DWARFDebugMacro>
DWARFContext::DWARFContextState::parseMacroOrMacinfo(MacroSecType SectionType) {
auto Macro = std::make_unique<DWARFDebugMacro>();
auto ParseAndDump = [&](DWARFDataExtractor &Data, bool IsMacro) {
if (Error Err = IsMacro ? Macro->parseMacro(SectionType == MacroSection
... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movl %edx, 0x124(%rsp)
movq 0x128(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x123(%rsp)
callq 0x1ee930
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rdi, 0x108(%rsp... | /DebugInfo/DWARF/DWARFContext.cpp |
llvm::DWARFContext::verify(llvm::raw_ostream&, llvm::DIDumpOptions) | bool DWARFContext::verify(raw_ostream &OS, DIDumpOptions DumpOpts) {
bool Success = true;
DWARFVerifier verifier(OS, *this, DumpOpts);
Success &= verifier.handleDebugAbbrev();
if (DumpOpts.DumpType & DIDT_DebugCUIndex)
Success &= verifier.handleDebugCUIndex();
if (DumpOpts.DumpType & DIDT_DebugTUIndex)
... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdx, 0x10(%rsp)
movq %rsi, %rax
movq 0x10(%rsp), %rsi
movq %rsi, 0x28(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rax, 0x1d8(%rsp)
movq %rsi, 0x1d0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x1, 0x1cf(%rsp)
movq 0x1d8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rs... | /DebugInfo/DWARF/DWARFContext.cpp |
llvm::DWARFContext::getLineTableForUnit(llvm::DWARFUnit*) | const DWARFDebugLine::LineTable *
DWARFContext::getLineTableForUnit(DWARFUnit *U) {
Expected<const DWARFDebugLine::LineTable *> ExpectedLineTable =
getLineTableForUnit(U, WarningHandler);
if (!ExpectedLineTable) {
WarningHandler(ExpectedLineTable.takeError());
return nullptr;
}
return *ExpectedLin... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x40, %rsi
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x1f3810
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rcx
mov... | /DebugInfo/DWARF/DWARFContext.cpp |
llvm::DWARFUnit::getNonSkeletonUnitDIE(bool, llvm::StringRef) | DWARFDie getNonSkeletonUnitDIE(bool ExtractUnitDIEOnly = true,
StringRef DWOAlternativeLocation = {}) {
parseDWO(DWOAlternativeLocation);
return DWO ? DWO->getUnitDIE(ExtractUnitDIEOnly)
: getUnitDIE(ExtractUnitDIEOnly);
} | subq $0x48, %rsp
movb %sil, %al
movq %rdx, 0x28(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x2879b0
m... | /llvm/DebugInfo/DWARF/DWARFUnit.h |
getFunctionNameAndStartLineForAddress(llvm::DWARFCompileUnit*, unsigned long, llvm::DINameKind, llvm::DILineInfoSpecifier::FileLineInfoKind, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&, st... | static bool getFunctionNameAndStartLineForAddress(
DWARFCompileUnit *CU, uint64_t Address, FunctionNameKind Kind,
DILineInfoSpecifier::FileLineInfoKind FileNameKind,
std::string &FunctionName, std::string &StartFile, uint32_t &StartLine,
std::optional<uint64_t> &StartAddress) {
// The address may corr... | subq $0x128, %rsp # imm = 0x128
movq 0x138(%rsp), %rax
movq 0x130(%rsp), %rax
movq %rdi, 0x118(%rsp)
movq %rsi, 0x110(%rsp)
movl %edx, 0x10c(%rsp)
movl %ecx, 0x108(%rsp)
movq %r8, 0x100(%rsp)
movq %r9, 0xf8(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x1f7f10
movq 0x118(%rsp), %rdi
movq 0x110(%rsp), %rsi
leaq 0xa8(%rs... | /DebugInfo/DWARF/DWARFContext.cpp |
llvm::DWARFListTableBase<llvm::DWARFDebugRnglist>::extract(llvm::DWARFDataExtractor, unsigned long*) | Error DWARFListTableBase<DWARFListType>::extract(DWARFDataExtractor Data,
uint64_t *OffsetPtr) {
clear();
if (Error E = extractHeaderAndOffsets(Data, OffsetPtr))
return E;
Data.setAddressSize(Header.getAddrSize());
Data = DWARFDataExtractor(Data, getHeaderOf... | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x70(%rsp)
movq %rdi, %rax
movq %rax, 0x58(%rsp)
leaq 0x170(%rsp), %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0x160(%rsp)
movq %rsi, 0x158(%rsp)
movq %rdx, 0x150(%rsp)
movq 0x158(%rsp), %rdi
movq %rdi, 0x68(%rsp)
callq 0x1fb6f0
movq 0x60(%rsp), %rsi
movb $0x0, 0x14f(%rsp... | /llvm/DebugInfo/DWARF/DWARFListTable.h |
llvm::DenseMapIterator<unsigned long, llvm::RelocAddrEntry, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::RelocAddrEntry>, true>::AdvancePastEmptyBuckets() | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x205ac0
movq %rax, 0x18(%rsp)
callq 0x205c00
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x221fd8
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x220810
mo... | /llvm/ADT/DenseMap.h |
llvm::DWARFDataExtractor::getInitialLength(unsigned long*, llvm::Error*) const | std::pair<uint64_t, dwarf::DwarfFormat>
DWARFDataExtractor::getInitialLength(uint64_t *Off, Error *Err) const {
ErrorAsOutParameter ErrAsOut(Err);
if (Err && *Err)
return {0, dwarf::DWARF32};
Cursor C(*Off);
uint64_t Length = getRelocatedValue(C, 4);
dwarf::DwarfFormat Format = dwarf::DWARF32;
if (Leng... | subq $0xa8, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
movq 0x80(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x222880
cmpq $0x0, 0x80(%rsp)
je 0x22264c
movq 0x80(%rsp), %rdi
callq 0x99640
testb $0x1, %al
jne 0x22261b
jmp 0x22264c
movl $0x0, 0x74(%rsp)
movb... | /DebugInfo/DWARF/DWARFDataExtractor.cpp |
llvm::DWARFAbbreviationDeclarationSet::extract(llvm::DataExtractor, unsigned long*) | Error DWARFAbbreviationDeclarationSet::extract(DataExtractor Data,
uint64_t *OffsetPtr) {
clear();
const uint64_t BeginOffset = *OffsetPtr;
Offset = BeginOffset;
DWARFAbbreviationDeclaration AbbrDecl;
uint32_t PrevAbbrCode = 0;
while (true) {
Expected<DWARF... | subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
leaq 0x150(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movq 0x138(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x222ff0
movq 0x40(%rsp), %rax
movq 0x130(%rsp), %rc... | /DebugInfo/DWARF/DWARFDebugAbbrev.cpp |
llvm::DWARFDebugAddrTable::extractAddresses(llvm::DWARFDataExtractor const&, unsigned long*, unsigned long) | Error DWARFDebugAddrTable::extractAddresses(const DWARFDataExtractor &Data,
uint64_t *OffsetPtr,
uint64_t EndOffset) {
assert(EndOffset >= *OffsetPtr);
uint64_t DataSize = EndOffset - *OffsetPtr;
assert(Data.isValidOffsetForDa... | subq $0xa8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rcx
movq 0x88(%rsp), %rdx
subq (%rdx), %rcx
movq %rcx, 0x78(%rsp)
movb $... | /DebugInfo/DWARF/DWARFDebugAddr.cpp |
llvm::SmallSet<llvm::DWARFDie, 3u, std::less<llvm::DWARFDie>>::insert(llvm::DWARFDie const&) | std::pair<const_iterator, bool> insert(const T &V) {
if (!isSmall()) {
auto [I, Inserted] = Set.insert(V);
return std::make_pair(const_iterator(I), Inserted);
}
VIterator I = vfind(V);
if (I != Vector.end()) // Don't reinsert if it already exists.
return std::make_pair(const_iterat... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x118(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x26b0e0
testb $0x1, %al
jne 0x2642a7
movq 0x28(%rsp), %rdi
addq $0x40, %rdi
movq 0x110(%rsp), %r... | /llvm/ADT/SmallSet.h |
llvm::DWARFFormValue::getAsRelativeReference() const | std::optional<uint64_t> DWARFFormValue::getAsRelativeReference() const {
switch (Form) {
case DW_FORM_ref1:
case DW_FORM_ref2:
case DW_FORM_ref4:
case DW_FORM_ref8:
case DW_FORM_ref_udata:
if (!U)
return std::nullopt;
return Value.uval;
default:
return std::nullopt;
}
} | subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzwl (%rax), %eax
addl $-0x11, %eax
subl $0x4, %eax
ja 0x275aba
jmp 0x275a8f
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x275aa6
leaq 0x18(%rsp), %rdi
callq 0xb9200
jmp 0x275ac4
movq (%rsp), %rsi
addq $0x8, %rsi
leaq 0x18(%rsp), %rdi
call... | /DebugInfo/DWARF/DWARFFormValue.cpp |
llvm::DWARFGdbIndex::SymTableEntry const* llvm::SmallVectorTemplateCommon<llvm::DWARFGdbIndex::SymTableEntry, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::DWARFGdbIndex::SymTableEntry, true>>(llvm::SmallVectorTemplateBase<llvm::DWARFGdbIndex::SymTableEntry, true>*, llvm::DWARFGdbIndex::Sy... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x58b6d0
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x58b4e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
ja 0x27bb44
movq 0x30(%... | /llvm/ADT/SmallVector.h |
llvm::Error llvm::DWARFContext::checkAddressSizeSupported<char const*, unsigned long>(unsigned int, std::error_code, char const*, char const* const&, unsigned long const&) | static Error checkAddressSizeSupported(unsigned AddressSize,
std::error_code EC, char const *Fmt,
const Ts &...Vals) {
if (isAddressSizeSupported(AddressSize))
return Error::success();
std::string Buffer;
raw_string_ostr... | subq $0x138, %rsp # imm = 0x138
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x140(%rsp), %rax
movq %rdi, 0x130(%rsp)
movl %edx, 0x120(%rsp)
movq %rcx, 0x128(%rsp)
movl %esi, 0x11c(%rsp)
movq %r8, 0x110(%rsp)
movq %r9, 0x108(%rsp)
movl 0x11c(%rsp), %edi
callq 0x227e80
testb $0x1, %al
jne 0x27d... | /llvm/DebugInfo/DWARF/DWARFContext.h |
llvm::json::OStream::State const* llvm::SmallVectorTemplateCommon<llvm::json::OStream::State, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::json::OStream::State, true>>(llvm::SmallVectorTemplateBase<llvm::json::OStream::State, true>*, llvm::json::OStream::State const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x58b6d0
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x58b4e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
ja 0x2aa0c4
movq 0x30(%... | /llvm/ADT/SmallVector.h |
int llvm::array_pod_sort_comparator<llvm::DWARFVerifier::verifyNameIndexBuckets(llvm::DWARFDebugNames::NameIndex const&, llvm::DataExtractor const&)::BucketInfo>(void const*, void const*) | inline int array_pod_sort_comparator(const void *P1, const void *P2) {
if (std::less<T>()(*reinterpret_cast<const T*>(P1),
*reinterpret_cast<const T*>(P2)))
return -1;
if (std::less<T>()(*reinterpret_cast<const T*>(P2),
*reinterpret_cast<const T*>(P1)))
return 1;
... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0xf(%rsp), %rdi
callq 0x2c38a0
testb $0x1, %al
jne 0x2c3858
jmp 0x2c3862
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2c388e
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0xe(%rsp), %rdi
callq 0x2c3... | /llvm/ADT/STLExtras.h |
llvm::formatv_object<decltype(std::make_tuple(support::detail::build_format_adapter(std::forward<llvm::StringRef&>(fp0)), support::detail::build_format_adapter(std::forward<unsigned long&>(fp0)), support::detail::build_format_adapter(std::forward<unsigned long>(fp0)), support::detail::build_format_adapter(std::forward<... | inline auto formatv(const char *Fmt, Ts &&...Vals)
-> formatv_object<decltype(std::make_tuple(
support::detail::build_format_adapter(std::forward<Ts>(Vals))...))> {
using ParamTuple = decltype(std::make_tuple(
support::detail::build_format_adapter(std::forward<Ts>(Vals))...));
return formatv_objec... | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x128(%rsp), %rax
movq 0x120(%rsp), %rax
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq %rcx, 0xf8(%rsp)
movq %r8, 0xf0(%rsp)
movq %r9, 0xe8(%rsp)
movq 0x108(%rsp), %rsi
leaq 0xd8(%rsp),... | /llvm/Support/FormatVariadic.h |
llvm::object::MachOObjectFile::isDebugSection(llvm::object::DataRefImpl) const | bool MachOObjectFile::isDebugSection(DataRefImpl Sec) const {
Expected<StringRef> SectionNameOrErr = getSectionName(Sec);
if (!SectionNameOrErr) {
// TODO: Report the error message properly.
consumeError(SectionNameOrErr.takeError());
return false;
}
StringRef SectionName = SectionNameOrErr.get();
... | subq $0xd8, %rsp
movq %rsi, 0xc8(%rsp)
movq %rdi, 0xc0(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rdx
movq (%rsi), %rax
leaq 0xa8(%rsp), %rdi
callq *0x90(%rax)
leaq 0xa8(%rsp), %rdi
callq 0xa1f10
testb $0x1, %al
jne 0x32f6b0
leaq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
call... | /Object/MachOObjectFile.cpp |
llvm::MachO::section_64 getStruct<llvm::MachO::section_64>(llvm::object::MachOObjectFile const&, char const*) | static T getStruct(const MachOObjectFile &O, const char *P) {
// Don't read before the beginning or past the end of the file
if (P < O.getData().begin() || P + sizeof(T) > O.getData().end())
report_fatal_error("Malformed MachO file.");
T Cmd;
memcpy(&Cmd, P, sizeof(T));
if (O.isLittleEndian() != sys::IsL... | subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2f7390
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xda720
movq 0x18(%rsp), %rcx
movq %rax, %rdx
movb $0x1, %al
cm... | /Object/MachOObjectFile.cpp |
llvm::Expected<llvm::ArrayRef<llvm::minidump::MemoryDescriptor>> llvm::object::MinidumpFile::getDataSliceAs<llvm::minidump::MemoryDescriptor>(llvm::ArrayRef<unsigned char>, unsigned long, unsigned long) | Expected<ArrayRef<T>> MinidumpFile::getDataSliceAs(ArrayRef<uint8_t> Data,
size_t Offset,
size_t Count) {
// Check for overflow.
if (Count > std::numeric_limits<size_t>::max() / sizeof(T))
return createEOFError... | subq $0x98, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x162230
movq %rax, %rcx
movq 0x18(%rsp), %rax
shrq $0x4, %rcx
cmpq %rcx, %rax
jbe 0x... | /llvm/Object/Minidump.h |
llvm::Expected<llvm::ArrayRef<llvm::minidump::Directory>> llvm::object::MinidumpFile::getDataSliceAs<llvm::minidump::Directory>(llvm::ArrayRef<unsigned char>, unsigned long, unsigned long) | Expected<ArrayRef<T>> MinidumpFile::getDataSliceAs(ArrayRef<uint8_t> Data,
size_t Offset,
size_t Count) {
// Check for overflow.
if (Count > std::numeric_limits<size_t>::max() / sizeof(T))
return createEOFError... | subq $0x98, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x162230
movl $0xc, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x18(%rsp), %... | /llvm/Object/Minidump.h |
llvm::DenseMap<llvm::minidump::StreamType, unsigned long, llvm::DenseMapInfo<llvm::minidump::StreamType, void>, llvm::detail::DenseMapPair<llvm::minidump::StreamType, unsigned long>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rax), %ecx
movl %ecx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x40, 0xc(%rsp)
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x94600
movl %eax, 0x8(%rsp)
leaq 0xc... | /llvm/ADT/DenseMap.h |
llvm::MachO::ArchitectureSet::arch_iterator<unsigned int>::findNextSetBit() | void findNextSetBit() {
if (Index == EndIndexVal)
return;
while (++Index < sizeof(Ty) * 8) {
if (*ArchSet & (1UL << Index))
return;
}
Index = EndIndexVal;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
cmpl $-0x1, (%rax)
jne 0x34f3e6
jmp 0x34f42c
jmp 0x34f3e8
movq -0x10(%rsp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
movl %eax, %eax
cmpq $0x20, %rax
jae 0x34f421
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
movl (%rax), %eax
movl (%rcx),... | /llvm/TextAPI/ArchitectureSet.h |
llvm::object::WasmObjectFile::getSymbolType(llvm::object::DataRefImpl) const | Expected<SymbolRef::Type>
WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
const WasmSymbol &Sym = getWasmSymbol(Symb);
switch (Sym.Info.Kind) {
case wasm::WASM_SYMBOL_TYPE_FUNCTION:
return SymbolRef::ST_Function;
case wasm::WASM_SYMBOL_TYPE_GLOBAL:
return SymbolRef::ST_Other;
case wasm::WASM_... | subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x35c460
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movzbl 0x10(%rax), %eax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
leaq 0x... | /Object/WasmObjectFile.cpp |
llvm::object::WasmObjectFile::getSymbolSectionIdImpl(llvm::object::WasmSymbol const&) const | uint32_t WasmObjectFile::getSymbolSectionIdImpl(const WasmSymbol &Sym) const {
switch (Sym.Info.Kind) {
case wasm::WASM_SYMBOL_TYPE_FUNCTION:
return CodeSection;
case wasm::WASM_SYMBOL_TYPE_GLOBAL:
return GlobalSection;
case wasm::WASM_SYMBOL_TYPE_DATA:
return DataSection;
case wasm::WASM_SYMBOL_T... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movzbl 0x10(%rax), %eax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
leaq 0x6c1ac2(%rip), %rcx # 0xa1e780
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rsp), %rax
movl 0x298(%rax), ... | /Object/WasmObjectFile.cpp |
readFloat32(llvm::object::WasmObjectFile::ReadContext&) | static int32_t readFloat32(WasmObjectFile::ReadContext &Ctx) {
if (Ctx.Ptr + 4 > Ctx.End)
report_fatal_error("EOF while reading float64");
int32_t Result = 0;
memcpy(&Result, Ctx.Ptr, sizeof(Result));
Ctx.Ptr += sizeof(Result);
return Result;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x4, %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x3606c2
leaq 0x6bf012(%rip), %rdi # 0xa1f6ca
movl $0x1, %esi
callq 0x5726b0
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, 0... | /Object/WasmObjectFile.cpp |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)1, true>>::getRelocatedSection(llvm::object::DataRefImpl) const | Expected<section_iterator>
ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const {
const Elf_Shdr *EShdr = getSection(Sec);
uintX_t Type = EShdr->sh_type;
if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA && Type != ELF::SHT_CREL)
return section_end();
Expected<const Elf_Shdr *> SecOrErr = EF.get... | subq $0xa8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rsi
callq 0x3a4a80
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
addq $0x4... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)0, true>>::create(llvm::MemoryBufferRef, bool) | Expected<ELFObjectFile<ELFT>>
ELFObjectFile<ELFT>::create(MemoryBufferRef Object, bool InitContent) {
auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer());
if (Error E = EFOrErr.takeError())
return std::move(E);
ELFObjectFile<ELFT> Obj = {Object, std::move(*EFOrErr), nullptr, nullptr,
... | subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rcx
movq %rcx, 0x28(%rsp)
movb %sil, %al
movq %rcx, %rdi
movq %rdi, 0x30(%rsp)
leaq 0x1e0(%rsp), %rdi
movq %rdi, 0x38(%rsp)
movq %rcx, 0x1d0(%rsp)
andb $0x1, %al
movb %al, 0x1cf(%rsp)
callq 0x91d60
movq %rax, 0x170(%rsp)
movq %rdx, 0x178(%rsp)
movq 0x170(%rsp), %rs... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)0, true>>::getSymbolType(llvm::object::DataRefImpl) const | Expected<SymbolRef::Type>
ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb) const {
Expected<const Elf_Sym *> SymOrErr = getSymbol(Symb);
if (!SymOrErr)
return SymOrErr.takeError();
switch ((*SymOrErr)->getType()) {
case ELF::STT_NOTYPE:
return SymbolRef::ST_Unknown;
case ELF::STT_SECTION:
ret... | subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x3ada10
leaq 0x50(%rsp), %rdi
callq 0x18f310
testb $0x1, %al... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)0, true>>::getSymbolSection(llvm::object::Elf_Sym_Impl<llvm::object::ELFType<(llvm::endianness)0, true>> const*, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, true>> const*) const | Expected<section_iterator>
ELFObjectFile<ELFT>::getSymbolSection(const Elf_Sym *ESym,
const Elf_Shdr *SymTab) const {
ArrayRef<Elf_Word> ShndxTable;
if (DotSymtabShndxSec) {
// TODO: Test this error.
Expected<ArrayRef<Elf_Word>> ShndxTableOrErr =
EF.getSHNDXTabl... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq %rcx, 0x118(%rsp)
movq 0x128(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x108(%rsp), %rdi
callq 0x146260
movq 0x48(%rsp), %rax
cmpq $0x0, 0x88(%rax... | /llvm/Object/ELFObjectFile.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalValue const*, unsigned int, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::GlobalValue const*, unsigned int>>, llvm::GlobalValue const*, unsigned int, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::... | void destroyAll() {
if (getNumBuckets() == 0) // Nothing to do.
return;
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3b22a0
cmpl $0x0, %eax
jne 0x3b23b2
jmp 0x3b244a
callq 0x3b21c0
movq %rax, 0x28(%rsp)
callq 0x3b2450
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x3b21d0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x3b21e0
movq %rax, 0x... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::MCSymbol const*, std::vector<llvm::StringRef, std::allocator<llvm::StringRef>>, llvm::DenseMapInfo<llvm::MCSymbol const*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol const*, std::vector<llvm::StringRef, std::allocator<llvm::StringRef>>>>, llvm::MCSymbol const*, std::vec... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3c1700
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x3bc5c0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x3c15b2
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rsp)
... | /llvm/ADT/DenseMap.h |
bool llvm::concat_iterator<llvm::GlobalValue const, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Function, false, false, void, false, void>, false, true>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::GlobalVariable, false, false, void, false, void>, false, true>, llvm::ilist_iterator<llvm:... | bool incrementHelper() {
auto &Begin = std::get<Index>(Begins);
auto &End = std::get<Index>(Ends);
if (Begin == End)
return false;
++Begin;
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3c2600
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x20, %rdi
callq 0x3c2600
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3c2060
testb $0x1, %al
jne 0x3c2463
jmp 0x3c246a
movb $0x0, 0x27(%rsp)
jmp 0x3c247... | /llvm/ADT/STLExtras.h |
void llvm::yaml::IO::processKeyWithDefault<std::vector<llvm::ArchYAML::Archive::Child, std::allocator<llvm::ArchYAML::Archive::Child>>, llvm::yaml::EmptyContext>(char const*, std::optional<std::vector<llvm::ArchYAML::Archive::Child, std::allocator<llvm::ArchYAML::Archive::Child>>>&, std::optional<std::vector<llvm::Arch... | void IO::processKeyWithDefault(const char *Key, std::optional<T> &Val,
const std::optional<T> &DefaultValue,
bool Required, Context &Ctx) {
assert(!DefaultValue && "std::optional<T> shouldn't have a value!");
void *SaveInfo;
bool UseDefault = true;
c... | subq $0xa8, %rsp
movb %r8b, %al
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
andb $0x1, %al
movb %al, 0x87(%rsp)
movq %r9, 0x78(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, (%rsp)
movb $0x1, 0x6f(%rsp)
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl... | /llvm/Support/YAMLTraits.h |
llvm::codeview::CVRecord<llvm::codeview::SymbolKind> llvm::codeview::SymbolSerializer::writeOneSymbol<llvm::codeview::RegRelativeSym>(llvm::codeview::RegRelativeSym&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&, llvm::codeview::CodeViewContainer) | static CVSymbol writeOneSymbol(SymType &Sym, BumpPtrAllocator &Storage,
CodeViewContainer Container) {
RecordPrefix Prefix{uint16_t(Sym.Kind)};
CVSymbol Result(&Prefix, sizeof(Prefix));
SymbolSerializer Serializer(Storage, Container);
consumeError(Serializer.visitSymbolB... | subq $0x10068, %rsp # imm = 0x10068
movq %rdi, 0x10050(%rsp)
movq %rsi, 0x10048(%rsp)
movl %edx, 0x10044(%rsp)
movq 0x10050(%rsp), %rax
movzwl (%rax), %esi
leaq 0x10040(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x400c50
movq 0x8(%rsp), %rsi
leaq 0x10058(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x4, %edx
callq 0x40... | /llvm/DebugInfo/CodeView/SymbolSerializer.h |
llvm::Expected<llvm::CodeViewYAML::LeafRecord> fromCodeViewRecordImpl<llvm::codeview::ProcedureRecord>(llvm::codeview::CVRecord<llvm::codeview::TypeLeafKind>) | static inline Expected<LeafRecord> fromCodeViewRecordImpl(CVType Type) {
LeafRecord Result;
auto Impl = std::make_shared<LeafRecordImpl<T>>(Type.kind());
if (auto EC = Impl->fromCodeViewRecord(Type))
return std::move(EC);
Result.Leaf = Impl;
return Result;
} | subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x44c9d0
leaq 0x60(%rsp), %rdi
callq 0x43bc30
movw %ax, 0x3e(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x3e(%rsp), %rsi
callq 0x44e600
leaq 0x40(%rsp), %rdi
ca... | /ObjectYAML/CodeViewYAMLTypes.cpp |
void llvm::yaml::IO::processKeyWithDefault<llvm::object::coff_load_configuration64, llvm::yaml::EmptyContext>(char const*, std::optional<llvm::object::coff_load_configuration64>&, std::optional<llvm::object::coff_load_configuration64> const&, bool, llvm::yaml::EmptyContext&) | void IO::processKeyWithDefault(const char *Key, std::optional<T> &Val,
const std::optional<T> &DefaultValue,
bool Required, Context &Ctx) {
assert(!DefaultValue && "std::optional<T> shouldn't have a value!");
void *SaveInfo;
bool UseDefault = true;
c... | subq $0x1c8, %rsp # imm = 0x1C8
movb %r8b, %al
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq %rdx, 0x1b0(%rsp)
movq %rcx, 0x1a8(%rsp)
andb $0x1, %al
movb %al, 0x1a7(%rsp)
movq %r9, 0x198(%rsp)
movq 0x1c0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movb $0x1, 0x18f(%rsp)
movq (%rdi), %rax
callq *0x10(%rax)
movb %al... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::WasmYAML::Export, std::allocator<llvm::WasmYAML::Export>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::WasmYAML::Export, std::allocator<llvm::WasmYAML::Export>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::WasmYAML::Export, std::allocato... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x52aafb
jmp 0x52ab11
movq 0x... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_ScalarBitSetTraits<llvm::WasmYAML::SymbolFlags>::value, void>::type llvm::yaml::yamlize<llvm::WasmYAML::SymbolFlags>(llvm::yaml::IO&, llvm::WasmYAML::SymbolFlags&, bool, llvm::yaml::EmptyContext&) | std::enable_if_t<has_ScalarBitSetTraits<T>::value, void>
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
bool DoClear;
if ( io.beginBitSetScalar(DoClear) ) {
if ( DoClear )
Val = T();
ScalarBitSetTraits<T>::bitset(io, Val);
io.endBitSetScalar();
}
} | subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
leaq 0x7(%rsp), %rsi
callq *0xc0(%rax)
testb $0x1, %al
jne 0x52fa14
jmp 0x52fa51
testb $0x1, 0x7(%rsp)
je 0x52fa34
movq %rsp, %rdi
xorl %esi, %esi
m... | /llvm/Support/YAMLTraits.h |
llvm::APInt::udivrem(llvm::APInt const&, llvm::APInt const&, llvm::APInt&, llvm::APInt&) | void APInt::udivrem(const APInt &LHS, const APInt &RHS,
APInt &Quotient, APInt &Remainder) {
assert(LHS.BitWidth == RHS.BitWidth && "Bit widths must be the same");
unsigned BitWidth = LHS.BitWidth;
// First, deal with the easy case
if (LHS.isSingleWord()) {
assert(RHS.U.VAL != 0 && "Div... | subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq 0xe0(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xc4(%rsp)
movq 0xe0(%rsp), %rdi
callq 0x4270d0
testb $0x1, %al
jne 0x53d2ef
jmp 0x53d3b4
movq 0xe0(%rsp), %rax
movq (%rax), %rax
movq 0xd8(%rsp), %rcx
xorl %edx... | /Support/APInt.cpp |
bool llvm::hashing::detail::store_and_advance<unsigned int>(char*&, char*, unsigned int const&, unsigned long) | bool store_and_advance(char *&buffer_ptr, char *buffer_end, const T& value,
size_t offset = 0) {
size_t store_size = sizeof(value) - offset;
if (buffer_ptr + store_size > buffer_end)
return false;
const char *value_data = reinterpret_cast<const char *>(&value);
memcpy(buffer_ptr, valu... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl $0x4, %eax
subq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
addq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jbe 0x53f662
movb $0x0, 0x37(%rsp)
jmp 0x53f69b
movq 0x18(%rsp), %rax
mov... | /llvm/ADT/Hashing.h |
CrashHandler(void*) | static void CrashHandler(void *) {
errs() << BugReportMsg ;
#ifndef __APPLE__
// On non-apple systems, just emit the crash stack trace to stderr.
PrintCurStackTrace(errs());
#else
// Emit the crash stack trace to a SmallString, put it where the system crash
// handling will find it, and also send it to stder... | pushq %rax
movq %rdi, (%rsp)
callq 0x5bb030
movq %rax, %rdi
movq 0x8a6adc(%rip), %rsi # 0xe2c330
callq 0x983b0
callq 0x5bb030
movq %rax, %rdi
callq 0x585690
popq %rax
retq
nopl (%rax,%rax)
| /Support/PrettyStackTrace.cpp |
llvm::reportInvalidSizeRequest(char const*) | void llvm::reportInvalidSizeRequest(const char *Msg) {
#ifndef STRICT_FIXED_SIZE_VECTORS
if (*ScalableErrorAsWarning) {
WithColor::warning() << "Invalid size request on a scalable vector; " << Msg
<< "\n";
return;
}
#endif
report_fatal_error("Invalid size request on a scalable vec... | pushq %rax
movq %rdi, (%rsp)
leaq 0x895c9c(%rip), %rdi # 0xe2e5a8
callq 0x5988b0
movq %rax, %rdi
addq $0x80, %rdi
callq 0x3b4620
testb $0x1, %al
jne 0x598926
jmp 0x598957
callq 0x59fac0
movq %rax, %rdi
leaq 0x497e37(%rip), %rsi # 0xa3076c
callq 0x983b0
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x983b0
movq %rax, %r... | /Support/TypeSize.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.