name string | code string | asm string | file string |
|---|---|---|---|
imrt::Collimator::Collimator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::set<int, std::less<int>, std::allocator<int>>) | Collimator::Collimator(string coord_filename, set<int> angles) {
ifstream coord_file(coord_filename.c_str(), ios::in);
string line, aux;
int angle;
if (! coord_file)
cerr << "ERROR: unable to open instance file: " << coord_filename << ", stopping! \n";
cout << "##Reading collimator coordinat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rdx, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x38(%rdi), %rax
andl $0x0, 0x38(%rdi)
... | /rilianx[P]IMRTsolver/src/base/Collimator.cpp |
imrt::Collimator::initializeCoordinates(std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&) | void Collimator::initializeCoordinates(vector < pair<int, string> >& coord_files) {
ifstream myfile;
string line, linec;
stringstream ss;
double x, y;
bool flag;
//nb_angles=coord_files.size();
for (int i=0 ; i < coord_files.size(); i++) {
// Open file
int angle = coord_files[i].first;
angle... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
leaq 0x220(%rsp), %rdi
callq 0x5390
leaq 0x88(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x58(%rsp), %rax
movq %rax, -0x1... | /rilianx[P]IMRTsolver/src/base/Collimator.cpp |
imrt::Collimator::insertYorder(double) | void Collimator::insertYorder(double y) {
bool flag=false;
if (find(ycoord.begin(), ycoord.end(), y) != ycoord.end())
flag=true;
for (int j=0; j< ycoord.size() && !flag; j++) {
if (ycoord[j] > y) {
ycoord.insert(ycoord.begin()+j, y);
flag=true;
}
}
if (!flag) ycoord... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsp, %r15
movsd %xmm0, (%r15)
leaq 0x78(%rdi), %rbx
movq 0x78(%rdi), %rdi
movq 0x80(%r14), %rsi
movq %r15, %rdx
callq 0x18f09
movq 0x80(%r14), %rcx
cmpq %rcx, %rax
setne %bpl
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rbx... | /rilianx[P]IMRTsolver/src/base/Collimator.cpp |
imrt::Collimator::printCoordinates() | void Collimator::printCoordinates() {
for (map<double, vector<double> >::iterator it = beam_coord.begin() ; it != beam_coord.end() ; it ++ ) {
for (int i=0; i < it->second.size(); i++) {
cout << it->first << " : " << it->second[i] << endl;
}
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
addq $0x8, %rbx
movq 0x15d83(%rip), %r15 # 0x2cfc8
leaq 0x6768(%rip), %r12 # 0x1d9b4
cmpq %rbx, %r14
je 0x172aa
xorl %r13d, %r13d
movq 0x30(%r14), %rax
subq 0x28(%r14), %rax
sarq $0x3, %rax
cmpq %r13, %rax
jbe 0x1729d
... | /rilianx[P]IMRTsolver/src/base/Collimator.cpp |
imrt::Collimator::printAxisValues() | void Collimator::printAxisValues() {
cout << "x:";
for (int i=0;i<xcoord.size(); i++ )
cout << xcoord[i] << ",";
cout << endl;
cout << "y:";
for (int i=0;i<ycoord.size(); i++ )
cout << ycoord[i] << ",";
cout << endl;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x15d02(%rip), %r14 # 0x2cfc8
leaq 0x65b2(%rip), %rsi # 0x1d87f
movq %r14, %rdi
callq 0x5330
xorl %r12d, %r12d
leaq 0x6445(%rip), %r15 # 0x1d724
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12... | /rilianx[P]IMRTsolver/src/base/Collimator.cpp |
imrt::Collimator::isActiveBeamAngle(int, int, int) | bool Collimator::isActiveBeamAngle(int x, int y, int angle) {
if (angle_row_beam_active[angle][x].first <= y && angle_row_beam_active[angle][x].second >= y)
return(true);
return(false);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x4(%rsp), %rsi
movl %ecx, (%rsi)
addq $0xa0, %r14
movq %r14, %rdi
callq 0x17b32
movslq %ebp, %r15
movq (%rax), %rax
cmpl %ebx, (%rax,%r15,8)
jg 0x174c9
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x17b32
movq (%r... | /rilianx[P]IMRTsolver/src/base/Collimator.cpp |
imrt::Collimator::generateReference() | void Collimator::generateReference () {
int i = 0;
reference[0] = make_pair(-1,-1);
i = 1;
for (int s = 1; s < getYdim(); s++) {
for (int j = 0; (j+s) < getYdim(); j++) {
reference[i] = make_pair(j,j+s);
i++;
}
}
reference[i] = make_pair(0, getYdim()-1);
ref_size ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x138(%rdi), %r14
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
movq %r14, %rdi
callq 0x17bd2
orq $-0x1, (%rax)
movq %rsp, %rax
movl $0x1, (%rax)
movl 0x98(%rbx), %ebp
pushq $0x1
popq %r12
cmpl %ebp, %r12d
jge 0x175aa
xorl %r13d,... | /rilianx[P]IMRTsolver/src/base/Collimator.cpp |
FileTest::Test5() | void FileTest::Test5()
{
File *pipe_files[ 2 ];
Selector s;
const char buffer[] = "Hello World";
File::pipe( pipe_files );
pipe_files[ File::PIPE_READER ]->setSelector( (FileListener*)this, &s );
int length = strlen( buffer );
int res = pipe_files[ File::PIPE_WRITER ]->write( buffer, length );
if ( res... | pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp # imm = 0x2D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2c8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x298(%rbp), %rdi
callq 0x41e0
movabsq $0x6f57206f6c6c6548, %rax # imm = 0x6F57206F6C6C6548
movq %rax, -0x2a8(%rbp)
movl $0x646c72, -0x2a0(%rbp)... | /benpayne[P]jhcommon/test/FileTest.cpp |
dprintf_DollarString | static long dprintf_DollarString(char *input, char **end)
{
int number = 0;
while(ISDIGIT(*input)) {
number *= 10;
number += *input-'0';
input++;
}
if(number && ('$'==*input++)) {
*end = input;
return number;
}
return 0;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
incq %r14
xorl %ebp, %ebp
movzbl -0x1(%r14), %edi
callq 0x3aa0
testl %eax, %eax
je 0x393d
imull $0xa, %ebp, %eax
movsbl -0x1(%r14), %ecx
leal (%rax,%rcx), %ebp
addl $-0x30, %ebp
incq %r14
jmp 0x391c
testl %ebp, %ebp
je 0x3950
cmpb $0x24, -0x1(%r14)
jne 0x... | /DarovskikhAndrei[P]curl/lib/mprintf.c |
main | int main()
{
cout << "--- state_machine playground ---\n";
SM sm;
cout << "states_count() : " << sm.states_count() << "\n";
cout << "current state : " << sm.state_int() << "\n";
cout << "tv1.size() : " << tv1.size() << "\n";
const auto all_ok = sm.test_transitions(tv1, true);
cout << "... | pushq %r14
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movq 0x5ce3(%rip), %rbx # 0x8fd0
leaq 0x2f58(%rip), %rsi # 0x624c
movl $0x21, %edx
movq %rbx, %rdi
callq 0x2150
leaq 0x40(%rsp), %rdi
callq 0x3634
leaq 0x2f5c(%rip), %rsi # 0x626e
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2150
movq 0x5caa(%r... | /mlutken[P]nestle/estl/fsm/playground/state_machine_playground.cpp |
estl::state_machine<cd_fsm_def>::next_state(cd_fsm_def::state_type, cd_fsm_def::inputs_type const&) const | state_type next_state(state_type state, const inputs_type& inputs) const {
const auto fn = get_switch_state_function(state);
if (!fn) {
throw state_not_found{};
}
return fn(inputs);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %eax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rdi,%rax), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5458
cmpq $0x0, 0x10(%r14)
je 0x5400
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x18(%rdi)
movl %eax, %ebx
movq 0x18(%rsp),... | /mlutken[P]nestle/estl/fsm/state_machine.hpp |
estl::state_machine<cd_fsm_def>::execute_actions(cd_fsm_def::state_type, cd_fsm_def::inputs_type const&, cd_fsm_def::outputs_type&) const | void execute_actions(state_type state, const inputs_type& inputs, outputs_type& outputs) const {
const auto fn = get_action_function(state);
if (!fn) {
throw state_not_found{};
}
fn(inputs, outputs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %edx
movq %rdi, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x5942
cmpq $0x0, 0x10(%r15)
je 0x58eb
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rdi)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x58e1
movq %rsp, %rd... | /mlutken[P]nestle/estl/fsm/state_machine.hpp |
estl::state_machine<cd_fsm_def>::get_action_function(cd_fsm_def::state_type) const | actions_fun get_action_function(state_type from_state) const
{
constexpr auto compare = [](const action_entry& lhs, state_type state) -> bool {
return lhs.state < state;
};
const auto it = std::lower_bound(actions_.begin(), actions_.end(), from_state, compare);
if (it !=... | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x3c8(%rsi), %rsi
movq 0x3d0(%rax), %rax
movq %rax, %rcx
subq %rsi, %rcx
testq %rcx, %rcx
jle 0x599a
shrq $0x3, %rcx
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdi
movq %rdi, %rcx
shrq %rcx
leaq (%rcx,%rcx,4), %r8
cmpl %edx, (%rsi,%r8,8)
ja... | /mlutken[P]nestle/estl/fsm/state_machine.hpp |
bool sptk::ReadStream<long>(long*, std::istream*) | bool ReadStream(T* data_to_read, std::istream* input_stream) {
if (NULL == data_to_read || NULL == input_stream || input_stream->eof()) {
return false;
}
const int type_byte(sizeof(*data_to_read));
input_stream->read(reinterpret_cast<char*>(data_to_read), type_byte);
return (type_byte == input_stream->g... | pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x62b8
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rbx,%rax)
jne 0x62b8
movq %rdi, %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x32a0
cmpq $0x8, 0x8(%rbx)
jne 0x62b8
movq (%rbx), %rax
movq -0x18(%rax), %ra... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<unsigned int>(unsigned int*, std::istream*) | bool ReadStream(T* data_to_read, std::istream* input_stream) {
if (NULL == data_to_read || NULL == input_stream || input_stream->eof()) {
return false;
}
const int type_byte(sizeof(*data_to_read));
input_stream->read(reinterpret_cast<char*>(data_to_read), type_byte);
return (type_byte == input_stream->g... | pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x63e8
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rbx,%rax)
jne 0x63e8
movq %rdi, %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x32a0
cmpq $0x4, 0x8(%rbx)
jne 0x63e8
movq (%rbx), %rax
movq -0x18(%rax), %ra... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<double>(int, int, std::vector<double, std::allocator<double>> const&, std::ostream*, int*) | bool WriteStream(int write_point, int write_size,
const std::vector<T>& sequence_to_write,
std::ostream* output_stream, int* actual_write_size) {
if (write_point < 0 || write_size <= 0 || NULL == output_stream) {
return false;
}
const int end(write_point + write_size);
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testl %edi, %edi
sets %al
testl %esi, %esi
setle %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
je 0x81dc
xorl %r12d, %r12d
jmp 0x8255
movq %rdx, %rbp
movl %esi, %r15d
movl %edi, %r13d
leal (%r15,%r13), %ecx
movq (%rdx... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::SymmetricMatrix::SymmetricMatrix(sptk::SymmetricMatrix const&) | SymmetricMatrix::SymmetricMatrix(const SymmetricMatrix& matrix)
: num_dimension_(matrix.num_dimension_),
data_(matrix.data_),
index_(num_dimension_) {
for (int i(0), j(0); i < num_dimension_; ++i, j += i) {
index_[i] = &data_[j];
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
leaq 0x735b(%rip), %rax # 0x11d60
movq %rax, (%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0xa512
leaq 0x28(%r15), %r14
movslq 0x8(%r15), %rsi
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
sptk::SymmetricMatrix::operator=(sptk::SymmetricMatrix const&) | SymmetricMatrix& SymmetricMatrix::operator=(const SymmetricMatrix& matrix) {
if (this != &matrix) {
num_dimension_ = matrix.num_dimension_;
data_ = matrix.data_;
index_.resize(num_dimension_);
for (int i(0), j(0); i < num_dimension_; ++i, j += i) {
index_[i] = &data_[j];
}
}
return *thi... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xaacf
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rbx)
addq $0x10, %rsi
leaq 0x10(%rbx), %r14
movq %r14, %rdi
callq 0xa5b2
leaq 0x28(%rbx), %r15
movslq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0xa4e0
movl 0x8(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
sptk::SymmetricMatrix::At(int, int) | double& SymmetricMatrix::At(int row, int column) {
if (row < column) {
std::swap(row, column);
}
if (column < 0 || num_dimension_ <= row) {
throw std::out_of_range(kErrorMessageForOutOfRange);
}
return index_[row][column];
} | pushq %r14
pushq %rbx
pushq %rax
cmpl %edx, %esi
movl %edx, %eax
cmovgl %esi, %eax
cmovll %esi, %edx
testl %edx, %edx
js 0xab72
cmpl %eax, 0x8(%rdi)
jle 0xab72
movslq %eax, %rcx
movq 0x28(%rdi), %rsi
movl %edx, %eax
shlq $0x3, %rax
addq (%rsi,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
sptk::SymmetricMatrix::GetDiagonal(std::vector<double, std::allocator<double>>*) const | bool SymmetricMatrix::GetDiagonal(
std::vector<double>* diagonal_elements) const {
if (NULL == diagonal_elements) {
return false;
}
if (diagonal_elements->size() != static_cast<std::size_t>(num_dimension_)) {
diagonal_elements->resize(num_dimension_);
}
for (int i(0); i < num_dimension_; ++i) {
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rsi, %rsi
je 0xac99
movq %rdi, %r14
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
sarq $0x3, %rcx
movl 0x8(%rdi), %eax
movslq %eax, %rsi
cmpq %rsi, %rcx
je 0xac73
movq %rbx, %rdi
callq 0x4cb2
movl 0x8(%r14), %eax
movq 0x28(%r14), %rcx
xorl %edx, %edx
testl %eax, %eax
cmo... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
r_code::ReadString[abi:cxx11](unsigned int*) | std::string ReadString(uint32_t *data)
{
std::string ret;
char *content = (char *)(data + 1);
for (size_t i = 0; content[i] != 0; ++i) {
ret += content[i];
}
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xcd00
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
mo... | /sandsmark[P]replicode/r_code/image.cpp |
r_code::SysView::write(unsigned int*) | void SysView::write(uint32_t *data)
{
data[0] = code.size();
data[1] = references.size();
size_t i = 0;
for (; i < code.size(); ++i) {
data[2 + i] = code[i].atom;
}
for (size_t j = 0; j < references.size(); ++j) {
data[2 + i + j] = references[j];
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
callq 0xc780
movq -0x28(%rbp), %rdi
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rdi
callq 0xc360
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ec... | /sandsmark[P]replicode/r_code/object.cpp |
r_code::SysView::trace() | void SysView::trace()
{
std::cout << " code size: " << code.size() << std::endl;
std::cout << " reference set size: " << references.size() << std::endl;
std::cout << "---code---" << std::endl;
for (const Atom &atom : code) {
atom.trace();
std::cout << std::endl;
}
std::cout << ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0xc215(%rip), %rdi # 0x1bfc0
leaq 0x6496(%rip), %rsi # 0x16248
callq 0xca00
movq -0x50(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x8, %rdi
callq 0xc780
movq -0x60(%rbp), %rdi
movq %rax, %rsi
call... | /sandsmark[P]replicode/r_code/object.cpp |
r_code::SysView::~SysView() | class REPLICODE_EXPORT SysView : public ImageObject
{
public:
SysView();
SysView(View *source);
void write(uint32_t *data);
void read(uint32_t *data);
size_t get_size() const;
void trace();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /sandsmark[P]replicode/r_code/object.h |
r_code::SysView::~SysView() | class REPLICODE_EXPORT SysView : public ImageObject
{
public:
SysView();
SysView(View *source);
void write(uint32_t *data);
void read(uint32_t *data);
size_t get_size() const;
void trace();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xcbe0
movq -0x10(%rbp), %rdi
callq 0xc990
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /sandsmark[P]replicode/r_code/object.h |
ViewTest::copyConstructorTest() | void ViewTest::copyConstructorTest() {
// scalar
{
// false, false
{
andres::View<int, false> v(&scalar_);
andres::View<int, false> w(v);
test(w.dimension() == v.dimension() &&
w.size() == v.size() &&
&(w(0)) == &(v(0)))... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r12
movq %rdi, 0x10(%rsp)
xorl %edi, %edi
callq 0x27190
leaq 0x10(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq $0x1, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
ViewTest::reshapeTest() | void ViewTest::reshapeTest()
{
float data[24];
for(std::size_t j=0; j<24; ++j) {
data[j] = static_cast<float>(j);
}
std::size_t shape[] = {2, 4, 3};
andres::View<float, false> v(&shape[0], &shape[3], data);
andres::View<float, false> w = v; // copy
std::size_t newShape[] = {4, 6... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movdqa 0xfd464(%rip), %xmm0 # 0x138070
movdqa 0xfd46c(%rip), %xmm1 # 0x138080
xorl %eax, %eax
movdqa 0xfd472(%rip), %xmm2 # 0x138090
movq %xmm1, %rcx
testq %rcx, %rcx
js 0x3ac32
xorps %xmm3, %xmm3
cvtsi2ss %rcx, %xmm3
jmp 0x3ac4a
movq ... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
ViewTest::compatibilityFunctionsTest() | void ViewTest::compatibilityFunctionsTest()
{
#ifdef MARRAY_COMPATIBILITY
// permuteDimensions
{
std::size_t shape[] = {2, 4, 3};
andres::Marray<float> m(&shape[0], &shape[3]);
std::size_t perm[] = {0, 2, 1};
andres::View<float> v = m.permuteDimensions(perm);
andres:... | retq
nop
| /bjoern-andres[P]marray/src/unittest/marray.cxx |
MarrayTest::reshapeTest() | void MarrayTest::reshapeTest() {
// 2D
{
std::vector<std::size_t> shape(2);
shape[0] = 6;
shape[1] = 4;
andres::Marray<int> m(shape.begin(), shape.end(), scalar_);
shape[0] = 4;
shape[1] = 6;
m.reshape(shape.begin(), shape.end());
test(m.shap... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x27190
movq %rax, %r14
leaq 0x10(%rax), %r15
movq $0x6, (%rax)
movq $0x4, 0x8(%rax)
leaq 0xfad85(%rip), %r8 # 0x1385e0
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %r9
movq %rax, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
ExpressionTemplateTest::constructionAndAssignmentTest() | void ExpressionTemplateTest::constructionAndAssignmentTest()
{
// Marray
{
std::size_t shape[] = {2, 3, 2};
andres::View<int> v(shape, shape+3, dataInt_);
andres::View<int> w(shape, shape+3, dataInt_ + 2);
andres::Marray<int> r(v + w); // construction
for(std::size_t z=0;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %r14
movaps 0xf9477(%rip), %xmm0 # 0x138630
leaq 0x118(%rsp), %rbx
movaps %xmm0, -0x18(%rbx)
movq $0x2, -0x8(%rbx)
leaq 0xc8(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0xf9400(%rip), %rcx # 0x1385e... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
DifferingTypesTest::constructionTest() | void DifferingTypesTest::constructionTest()
{
// Marray
{
// from View
{
std::size_t shape[] = {3, 2, 4};
andres::View<short> v(shape, shape+3, dataShort_);
andres::Marray<int> m(v);
test(v.size() == m.size());
for(std::size_t j=0; j<v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movaps 0xf93d3(%rip), %xmm0 # 0x138ad0
leaq 0xb8(%rsp), %rdx
movaps %xmm0, -0x18(%rdx)
movq $0x4, -0x8(%rdx)
addq $0x60, %rbx
leaq 0x18(%rsp), %rdi
movq %rbx, -0x8(%rdi)
leaq 0xf8ebb(%rip), %rcx # 0x1385e0
leaq 0xa0(%rsp), %r... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
DifferingTypesTest::assignmentTest() | void DifferingTypesTest::assignmentTest()
{
// View
{
// from constant
{
std::size_t shape[] = {3, 2, 4};
andres::View<short> v(shape, shape+3, dataShort_);
v = 2;
for(std::size_t j=0; j<v.size(); ++j) {
test(v(j) == 2);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movaps 0xf8edb(%rip), %xmm0 # 0x138ad0
leaq 0x68(%rsp), %rdx
movaps %xmm0, -0x18(%rdx)
movq $0x4, -0x8(%rdx)
leaq 0x60(%rdi), %rax
leaq 0x10(%rsp), %rdi
movq %rax, 0xb8(%rsp)
movq %rax, -0x8(%rdi)
leaq 0xf89be(%rip), %... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
DifferingTypesTest::nonBasicTypesTest() | void DifferingTypesTest::nonBasicTypesTest()
{
std::size_t shape[] = {3, 4};
andres::Marray<MyTestType> m(shape, shape + 2);
std::size_t base[] = {0, 0};
shape[0] = 2;
shape[1] = 2;
andres::View<MyTestType> v = m.view(base, shape);
v(0, 1) = MyTestType();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movaps 0xf550f(%rip), %xmm0 # 0x138160
leaq 0x10(%rsp), %rdx
movaps %xmm0, -0x10(%rdx)
leaq 0xf597f(%rip), %r8 # 0x1385e0
leaq 0x68(%rsp), %rdi
movq %rsp, %rbx
leaq 0x28(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rsi
movq %r14, %rcx
movq %r15, %r9
callq 0x4fa... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
DifferingTypesTest::typePromotionTest() | void DifferingTypesTest::typePromotionTest()
{
std::size_t shape[] = {3, 4};
andres::Marray<unsigned char> a(shape, shape + 2, 250);
andres::Marray<int> b(shape, shape + 2, 1000);
for(std::size_t j=0; j<a.size(); ++j) {
test((a + b)(j) == 1250);
test((a - b)(j) == -750);
test((b ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movaps 0xf53e2(%rip), %xmm0 # 0x138160
leaq 0x30(%rsp), %rbx
movaps %xmm0, -0x10(%rbx)
leaq 0x80(%rsp), %rcx
movb $-0x6, (%rcx)
leaq 0xf5847(%rip), %r14 # 0x1385e0
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %r15
leaq 0x8(%rsp), %r12
m... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
main | int main()
{
{ GlobalFunctionTest t; t.shapeStrideTest(); }
{ ViewTest t; t.coordinatesToOffsetTest<false>(); }
{ ViewTest t; t.coordinatesToOffsetTest<true>(); }
{ ViewTest t; t.coordinatesToIndexTest<false>(); }
{ ViewTest t; t.coordinatesToIndexTest<true>(); }
{ ViewTest t; t.indexToCoordin... | pushq %rbx
subq $0x260, %rsp # imm = 0x260
callq 0x273cc
movl $0x2a, 0xc(%rsp)
movdqa 0xf4eb9(%rip), %xmm0 # 0x138010
movl $0x19, %eax
movdqa 0xf4ebc(%rip), %xmm2 # 0x138020
movdqu %xmm0, -0x54(%rsp,%rax,4)
movdqa %xmm0, %xmm1
paddd %xmm0, %xmm1
movdqu %xmm1, 0xc(%rsp,%rax,4)
paddd %xmm2, %xmm0
addq $0... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
andres::View<int, true, std::allocator<unsigned long>>::dimension() const | inline const std::size_t
View<T, isConst, A>::dimension() const
{
marray_detail::Assert(MARRAY_NO_DEBUG || this->data_ != 0);
return geometry_.dimension();
} | pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, (%rdi)
je 0x44f3c
movq 0x28(%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0xf3bf2(%rip), %rsi # 0x138b42
movq %rax, %rdi
callq 0x27080
movq 0x12c091(%rip), %rsi # 0x170ff0
movq 0x12c04a(%rip), %rdx # 0x170fb... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, false, std::allocator<unsigned long>>::shape(unsigned long) const | inline const std::size_t
View<T, isConst, A>::shape
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.shape(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe9fe4
cmpq $0x0, (%r14)
je 0x44fff
cmpq %rbx, 0x28(%r14)
jbe 0x4501d
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0xf3b2f(%rip), %rsi # 0x138b42
mov... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, false, std::allocator<unsigned long>>::operator()(unsigned long) | inline typename View<T, isConst, A>::reference
View<T, isConst, A>::operator()
(
const std::size_t value
)
{
testInvariant();
if(dimension() == 0) {
marray_detail::Assert(MARRAY_NO_ARG_TEST || value == 0);
return data_[0];
}
else {
std::size_t offset;
indexToOffset(va... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xe9fe4
movq (%rbx), %rax
testq %rax, %rax
je 0x450b5
cmpq $0x0, 0x28(%rbx)
je 0x450a6
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xea254
movq (%r15), %rax
shlq $0x2, %rax
addq (%rbx), %rax
jmp 0x450a... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, true, std::allocator<unsigned long>>::operator()(unsigned long) | inline typename View<T, isConst, A>::reference
View<T, isConst, A>::operator()
(
const std::size_t value
)
{
testInvariant();
if(dimension() == 0) {
marray_detail::Assert(MARRAY_NO_ARG_TEST || value == 0);
return data_[0];
}
else {
std::size_t offset;
indexToOffset(va... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xea468
movq (%rbx), %rax
testq %rax, %rax
je 0x451fb
cmpq $0x0, 0x28(%rbx)
je 0x451ec
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xea6d8
movq (%r15), %rax
shlq $0x2, %rax
addq (%rbx), %rax
jmp 0x451f... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<float, true, std::allocator<unsigned long>>::shape(unsigned long) const | inline const std::size_t
View<T, isConst, A>::shape
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.shape(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xee160
cmpq $0x0, (%r14)
je 0x462bb
cmpq %rbx, 0x28(%r14)
jbe 0x462d9
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0xf2873(%rip), %rsi # 0x138b42
mov... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Marray<float, std::allocator<unsigned long>>& andres::Marray<float, std::allocator<unsigned long>>::operator=<andres::BinaryViewExpressionScalarFirst<andres::View<float, true, std::allocator<unsigned long>>, float, float, andres::marray_detail::Plus<float, float, float>>, float>(andres::ViewExpression<andres::B... | inline Marray<T, A>&
Marray<T, A>::operator=
(
const ViewExpression<E, Te>& expression
)
{
if(expression.overlaps(*this)) {
Marray<T, A> m(expression); // temporary copy
(*this) = m; // recursive call
}
else {
// re-allocate memory (if necessary)
if(this->size() != expres... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0xfcae8
testb %al, %al
je 0x4638c
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0xfc2c2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8a82
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Marray<int, std::allocator<unsigned long>>& andres::Marray<int, std::allocator<unsigned long>>::operator=<andres::BinaryViewExpression<andres::View<int, true, std::allocator<unsigned long>>, int, andres::View<int, true, std::allocator<unsigned long>>, int, andres::marray_detail::Minus<int, int, int>>, int>(andr... | inline Marray<T, A>&
Marray<T, A>::operator=
(
const ViewExpression<E, Te>& expression
)
{
if(expression.overlaps(*this)) {
Marray<T, A> m(expression); // temporary copy
(*this) = m; // recursive call
}
else {
// re-allocate memory (if necessary)
if(this->size() != expres... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x10501e
testb %al, %al
je 0x46b60
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x47e92
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf5f3a
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Marray<float, std::allocator<unsigned long>>& andres::Marray<float, std::allocator<unsigned long>>::operator=<andres::BinaryViewExpressionScalarSecond<andres::View<float, true, std::allocator<unsigned long>>, float, float, andres::marray_detail::Minus<float, float, float>>, float>(andres::ViewExpression<andres:... | inline Marray<T, A>&
Marray<T, A>::operator=
(
const ViewExpression<E, Te>& expression
)
{
if(expression.overlaps(*this)) {
Marray<T, A> m(expression); // temporary copy
(*this) = m; // recursive call
}
else {
// re-allocate memory (if necessary)
if(this->size() != expres... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x10697a
testb %al, %al
je 0x470f8
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x106154
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8a82
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rs... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Marray<float, std::allocator<unsigned long>>& andres::Marray<float, std::allocator<unsigned long>>::operator=<andres::BinaryViewExpressionScalarFirst<andres::View<float, true, std::allocator<unsigned long>>, float, float, andres::marray_detail::Minus<float, float, float>>, float>(andres::ViewExpression<andres::... | inline Marray<T, A>&
Marray<T, A>::operator=
(
const ViewExpression<E, Te>& expression
)
{
if(expression.overlaps(*this)) {
Marray<T, A> m(expression); // temporary copy
(*this) = m; // recursive call
}
else {
// re-allocate memory (if necessary)
if(this->size() != expres... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x1079ec
testb %al, %al
je 0x47630
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x47b76
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8a82
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Marray<float, std::allocator<unsigned long>>::Marray<andres::BinaryViewExpressionScalarFirst<andres::View<float, true, std::allocator<unsigned long>>, float, float, andres::marray_detail::Minus<float, float, float>>, float>(andres::ViewExpression<andres::BinaryViewExpressionScalarFirst<andres::View<float, true,... | inline
Marray<T, A>::Marray
(
const ViewExpression<E, Te>& expression,
const allocator_type& allocator
)
: dataAllocator_(allocator)
{
this->data_ = dataAllocator_.allocate(expression.size());
if(expression.dimension() == 0) {
this->geometry_ = geometry_type(0,
static_cast<const ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c(%rdi)
callq 0xec76a
leaq 0x40(%rbx), %rdi
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Marray<int, std::allocator<unsigned long>>::Marray<andres::BinaryViewExpression<andres::View<int, true, std::allocator<unsigned long>>, int, andres::View<int, true, std::allocator<unsigned long>>, int, andres::marray_detail::Minus<int, int, int>>, int>(andres::ViewExpression<andres::BinaryViewExpression<andres:... | inline
Marray<T, A>::Marray
(
const ViewExpression<E, Te>& expression,
const allocator_type& allocator
)
: dataAllocator_(allocator)
{
this->data_ = dataAllocator_.allocate(expression.size());
if(expression.dimension() == 0) {
this->geometry_ = geometry_type(0,
static_cast<const ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c(%rdi)
callq 0xe9fe4
leaq 0x40(%rbx), %rdi
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Marray<int, std::allocator<unsigned long>>& andres::Marray<int, std::allocator<unsigned long>>::operator=<andres::BinaryViewExpression<andres::View<int, true, std::allocator<unsigned long>>, int, andres::View<int, true, std::allocator<unsigned long>>, int, andres::marray_detail::DividedBy<int, int, int>>, int>(... | inline Marray<T, A>&
Marray<T, A>::operator=
(
const ViewExpression<E, Te>& expression
)
{
if(expression.overlaps(*this)) {
Marray<T, A> m(expression); // temporary copy
(*this) = m; // recursive call
}
else {
// re-allocate memory (if necessary)
if(this->size() != expres... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x116d74
testb %al, %al
je 0x49c82
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x4ad1e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf5f3a
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Marray<float, std::allocator<unsigned long>>& andres::Marray<float, std::allocator<unsigned long>>::operator=<andres::BinaryViewExpression<andres::View<float, true, std::allocator<unsigned long>>, float, andres::View<float, true, std::allocator<unsigned long>>, float, andres::marray_detail::DividedBy<float, flo... | inline Marray<T, A>&
Marray<T, A>::operator=
(
const ViewExpression<E, Te>& expression
)
{
if(expression.overlaps(*this)) {
Marray<T, A> m(expression); // temporary copy
(*this) = m; // recursive call
}
else {
// re-allocate memory (if necessary)
if(this->size() != expres... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x117a1e
testb %al, %al
je 0x49f4e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x11713a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8a82
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rs... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpressionScalarFirst<andres::View<int, false, std::allocator<unsigned long>>, int, int, andres::marray_detail::Minus<int, int, int>>::operator()(unsigned long, unsigned long, unsigned long) const | const value_type operator()(const std::size_t c0, const std::size_t c1, const std::size_t c2) const
{ return binaryFunctor_(scalar_, e_(c0, c1, c2)); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %r12
movq %r12, %rdi
callq 0xe9fe4
movq (%r12), %r14
testq %r14, %r14
je 0x4c528
cmpq $0x3, 0x28(%r12)
jne 0x4c528
movq %r12, %rdi
xorl %esi, %esi
callq 0xeaae4
mov... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpression<andres::View<int, false, std::allocator<unsigned long>>, int, andres::View<int, false, std::allocator<unsigned long>>, int, andres::marray_detail::Minus<int, int, int>>::operator()(unsigned long, unsigned long, unsigned long) const | const value_type operator()(const std::size_t c0, const std::size_t c1, const std::size_t c2) const
{ return binaryFunctor_(e1_(c0, c1, c2), e2_(c0, c1, c2)); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq (%rdi), %r12
movq %r12, %rdi
callq 0xe9fe4
movq (%r12), %rbx
testq %rbx, %rbx
je 0x4c6f7
cmpq $0x3, 0x28(%r12)
jne 0x4c6f7
movq %r12, %rdi
xorl %esi, %esi
callq 0x... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpressionScalarSecond<andres::View<int, false, std::allocator<unsigned long>>, int, int, andres::marray_detail::Times<int, int, int>>::operator()(unsigned long, unsigned long, unsigned long) const | const value_type operator()(const std::size_t c0, const std::size_t c1, const std::size_t c2) const
{ return binaryFunctor_(e_(c0, c1, c2), scalar_); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %r12
movq %r12, %rdi
callq 0xe9fe4
movq (%r12), %r14
testq %r14, %r14
je 0x4c889
cmpq $0x3, 0x28(%r12)
jne 0x4c889
movq %r12, %rdi
xorl %esi, %esi
callq 0xeaae4
mov... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<float, true, std::allocator<unsigned long>>::operator()(unsigned long) | inline typename View<T, isConst, A>::reference
View<T, isConst, A>::operator()
(
const std::size_t value
)
{
testInvariant();
if(dimension() == 0) {
marray_detail::Assert(MARRAY_NO_ARG_TEST || value == 0);
return data_[0];
}
else {
std::size_t offset;
indexToOffset(va... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xee160
movq (%rbx), %rax
testq %rax, %rax
je 0x4e389
cmpq $0x0, 0x28(%rbx)
je 0x4e37a
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xf05a8
movq (%r15), %rax
shlq $0x2, %rax
addq (%rbx), %rax
jmp 0x4e37... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpressionScalarFirst<andres::View<short, false, std::allocator<unsigned long>>, short, int, andres::marray_detail::Plus<int, short, int>>::operator()(unsigned long, unsigned long, unsigned long) const | const value_type operator()(const std::size_t c0, const std::size_t c1, const std::size_t c2) const
{ return binaryFunctor_(scalar_, e_(c0, c1, c2)); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %r12
movq %r12, %rdi
callq 0x11cea8
movq (%r12), %r14
testq %r14, %r14
je 0x4edf9
cmpq $0x3, 0x28(%r12)
jne 0x4edf9
movq %r12, %rdi
xorl %esi, %esi
callq 0x120b14
m... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpression<andres::View<short, false, std::allocator<unsigned long>>, short, andres::View<int, false, std::allocator<unsigned long>>, int, andres::marray_detail::Minus<short, int, int>>::operator()(unsigned long, unsigned long, unsigned long) const | const value_type operator()(const std::size_t c0, const std::size_t c1, const std::size_t c2) const
{ return binaryFunctor_(e1_(c0, c1, c2), e2_(c0, c1, c2)); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq (%rdi), %r12
movq %r12, %rdi
callq 0x11cea8
movq (%r12), %rbx
testq %rbx, %rbx
je 0x4f274
cmpq $0x3, 0x28(%r12)
jne 0x4f274
movq %r12, %rdi
xorl %esi, %esi
callq 0... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpressionScalarFirst<andres::View<short, false, std::allocator<unsigned long>>, short, int, andres::marray_detail::Times<int, short, int>>::operator()(unsigned long, unsigned long, unsigned long) const | const value_type operator()(const std::size_t c0, const std::size_t c1, const std::size_t c2) const
{ return binaryFunctor_(scalar_, e_(c0, c1, c2)); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %r12
movq %r12, %rdi
callq 0x11cea8
movq (%r12), %r14
testq %r14, %r14
je 0x4f34e
cmpq $0x3, 0x28(%r12)
jne 0x4f34e
movq %r12, %rdi
xorl %esi, %esi
callq 0x120b14
m... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void ViewTest::emptyConstructorTest<true>() | void ViewTest::emptyConstructorTest() {
andres::View<int, constTarget> v;
test(v.size() == 0
);
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
xorl %eax, %eax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c(%rdi)
callq 0xea468
cmpq $0x0, 0x38(%rsp)
jne 0x532af
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::scalarConstructorTest<false>() | void ViewTest::scalarConstructorTest() {
andres::View<int, constTarget> v(&scalar_);
test(v.size() == 1 &&
v.dimension() == 0);
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x8(%rsp), %rbx
movq %rdi, (%rbx)
xorl %edi, %edi
callq 0x27190
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
movq $0x1, 0x30(%rbx)
movl $0x1, 0x38(%rbx)
movb $0x1, 0x3c(%rbx)
movq %rbx, %rdi
callq 0xe9fe4
cmpq $0x1, 0x38(%rsp)
jne 0x... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::scalarConstructorTest<true>() | void ViewTest::scalarConstructorTest() {
andres::View<int, constTarget> v(&scalar_);
test(v.size() == 1 &&
v.dimension() == 0);
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x8(%rsp), %rbx
movq %rdi, (%rbx)
xorl %edi, %edi
callq 0x27190
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
movq $0x1, 0x30(%rbx)
movl $0x1, 0x38(%rbx)
movb $0x1, 0x3c(%rbx)
movq %rbx, %rdi
callq 0xea468
cmpq $0x1, 0x38(%rsp)
jne 0x... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::shapeConstructorTest<false>() | void ViewTest::shapeConstructorTest() {
// 1D
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
test(v.dimension() == shape.size() &&
v.size() == 24
);
for(unsigned shor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movl $0x8, %edi
callq 0x27190
movq %rax, %rbx
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
addq $0x4, %r14
leaq 0x18(%rsp), %rdi
movq %r14, 0x8(%rsp)
movq %r14, -0x8(%rdi)
leaq 0xe5088(%rip), %rcx # 0x1385e0
leaq 0x7(%rsp)... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::shapeConstructorTest<true>() | void ViewTest::shapeConstructorTest() {
// 1D
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
test(v.dimension() == shape.size() &&
v.size() == 24
);
for(unsigned shor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movl $0x8, %edi
callq 0x27190
movq %rax, %rbx
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
addq $0x4, %r14
leaq 0x18(%rsp), %rdi
movq %r14, 0x8(%rsp)
movq %r14, -0x8(%rdi)
leaq 0xe4870(%rip), %rcx # 0x1385e0
leaq 0x7(%rsp)... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::shapeAssignTest<false>() | void ViewTest::shapeAssignTest() {
// scalar...
{
// to scalar
{
andres::View<int, constTarget> v(&scalar_);
std::vector<std::size_t> shape(0);
v.assign(shape.begin(), shape.end(), data_);
test(v.dimension() == shape.size() &&
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
movq %rdi, 0x18(%rsp)
xorl %edi, %edi
callq 0x27190
leaq 0x18(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq $0x1, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::shapeAssignTest<true>() | void ViewTest::shapeAssignTest() {
// scalar...
{
// to scalar
{
andres::View<int, constTarget> v(&scalar_);
std::vector<std::size_t> shape(0);
v.assign(shape.begin(), shape.end(), data_);
test(v.dimension() == shape.size() &&
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
movq %rdi, 0x18(%rsp)
xorl %edi, %edi
callq 0x27190
leaq 0x18(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq $0x1, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::queryTest<false>() | void ViewTest::queryTest(){
// scalar
{
andres::View<int, constTarget> v(&scalar_);
test(v.dimension()== 0 &&
v.size()== 1);
}
// 1D
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(),... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rdi, 0x10(%rsp)
xorl %edi, %edi
callq 0x27190
leaq 0x10(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq $0x1, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c(%rdi)
callq 0xe9fe4
cmpq $0x0, 0... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::queryTest<true>() | void ViewTest::queryTest(){
// scalar
{
andres::View<int, constTarget> v(&scalar_);
test(v.dimension()== 0 &&
v.size()== 1);
}
// 1D
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(),... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rdi, 0x10(%rsp)
xorl %edi, %edi
callq 0x27190
leaq 0x10(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq $0x1, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c(%rdi)
callq 0xea468
cmpq $0x0, 0... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::elementAccessTest<false>() | void ViewTest::elementAccessTest(){
// element access by coordinate
{
// 2D
{
std::vector<std::size_t> shape(2);
shape[0] = 6;
shape[1] = 4;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
std::vector<std::size_t> w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x27190
movq %rax, %r14
leaq 0x10(%rax), %rdx
movq $0x6, (%rax)
movq $0x4, 0x8(%rax)
movq %rbx, 0x80(%rsp)
leaq 0x4(%rbx), %rax
leaq 0x40(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rax, -0x8(%rdi)
leaq... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::elementAccessTest<true>() | void ViewTest::elementAccessTest(){
// element access by coordinate
{
// 2D
{
std::vector<std::size_t> shape(2);
shape[0] = 6;
shape[1] = 4;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
std::vector<std::size_t> w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x27190
movq %rax, %r14
leaq 0x10(%rax), %rdx
movq $0x6, (%rax)
movq $0x4, 0x8(%rax)
movq %rbx, 0x80(%rsp)
leaq 0x4(%rbx), %rax
leaq 0x40(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rax, -0x8(%rdi)
leaq... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::subViewsTest<false>() | void ViewTest::subViewsTest(){
// 1D with...
{
// scalar sub-view
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
std::vector<std::size_t> base(1);
base[0] = 4;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r13
movl $0x8, %edi
callq 0x27190
movq %rax, %r14
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
addq $0x4, %r13
leaq 0x68(%rsp), %rdi
movq %r13, -0x8(%rdi)
leaq 0x99a16(%rip), %rcx # 0x1385e0
leaq 0x8(%rsp), %r9
movq %rax, %rsi... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::iteratorAccessTest<false>() | void ViewTest::iteratorAccessTest(){
// 1D
{
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
typename andres::View<int, constTarget>::iterator it;
it = v.begin();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movl $0x8, %edi
callq 0x27190
movq %rax, %r14
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
leaq 0x4(%rbx), %r13
leaq 0x68(%rsp), %rdi
movq %r13, -0x8(%rdi)
leaq 0x93a4e(%rip), %rcx # 0x1385e0
movq %rsp, %r9
movq %rax, %rsi... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::iteratorAccessTest<true>() | void ViewTest::iteratorAccessTest(){
// 1D
{
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
typename andres::View<int, constTarget>::iterator it;
it = v.begin();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movl $0x8, %edi
callq 0x27190
movq %rax, %r14
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
leaq 0x4(%rbx), %r12
leaq 0x68(%rsp), %rdi
movq %r12, -0x8(%rdi)
leaq 0x91a10(%rip), %rcx # 0x1385e0
movq %rsp, %r9
movq %rax, %rsi... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::coordinateBindingTest<false>() | void ViewTest::coordinateBindingTest() {
// 1D
{
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::View<int, constTarget> w = v.boundView(0,7);
test(w.dimension()==0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
movl $0x8, %edi
callq 0x27190
movq %rax, %r14
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
leaq 0x4(%rbx), %rax
leaq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
movq %rax, -0x8(%rdi)
leaq 0x8fa77(%rip), %rcx # 0x1385e0
leaq 0x60... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::transposeTest<false>() | void ViewTest::transposeTest()
{
// 2D
{
std::vector<std::size_t> shape(2);
shape[0] = 6;
shape[1] = 4;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::View<int, constTarget> w1(shape.begin(), shape.end(), data_);
andres::View<int, co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %r14
movl $0x10, %edi
callq 0x27190
movq %rax, %r15
leaq 0x10(%rax), %rbx
movq $0x6, (%rax)
movq $0x4, 0x8(%rax)
addq $0x4, %r14
leaq 0x68(%rsp), %rdi
movq %r14, 0x18(%rsp)
movq %r14, -0x8(%rdi)
leaq ... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::transposeTest<true>() | void ViewTest::transposeTest()
{
// 2D
{
std::vector<std::size_t> shape(2);
shape[0] = 6;
shape[1] = 4;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::View<int, constTarget> w1(shape.begin(), shape.end(), data_);
andres::View<int, co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %r14
movl $0x10, %edi
callq 0x27190
movq %rax, %r15
leaq 0x10(%rax), %rbx
movq $0x6, (%rax)
movq $0x4, 0x8(%rax)
addq $0x4, %r14
leaq 0x68(%rsp), %rdi
movq %r14, 0x18(%rsp)
movq %r14, -0x8(%rdi)
leaq ... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::permuteTest<true>() | void ViewTest::permuteTest() {
// 2D
{
std::vector<std::size_t> shape(2);
shape[0] = 6;
shape[1] = 4;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::View<int, constTarget> w1(shape.begin(), shape.end(), data_);
andres::View<int, cons... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, %r14
movl $0x10, %edi
callq 0x27190
leaq 0x10(%rax), %rbx
movq $0x6, (%rax)
movq $0x4, 0x8(%rax)
addq $0x4, %r14
leaq 0x20(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0x8764b(%rip), %rcx # 0x1385e0
lea... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::shiftOperatorTest<false, (andres::CoordinateOrder)1>() | void ViewTest::shiftOperatorTest() {
// 2D
{
std::vector<std::size_t> shape(2);
shape[0] = 6;
shape[1] = 4;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_, internalFirstMajorOrder);
andres::View<int, constTarget> w1(shape.begin(), shape.end(), data_, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rdi, %r14
movl $0x10, %edi
callq 0x27190
leaq 0x10(%rax), %rbx
movq $0x6, (%rax)
movq $0x4, 0x8(%rax)
addq $0x4, %r14
leaq 0x1a0(%rsp), %rcx
movl $0x1, (%rcx)
leaq 0x20(%rsp), %rdi
movq %r14, -0x8(%rdi)
le... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void ViewTest::shiftOperatorTest<false, (andres::CoordinateOrder)0>() | void ViewTest::shiftOperatorTest() {
// 2D
{
std::vector<std::size_t> shape(2);
shape[0] = 6;
shape[1] = 4;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_, internalFirstMajorOrder);
andres::View<int, constTarget> w1(shape.begin(), shape.end(), data_, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rdi, %r14
movl $0x10, %edi
callq 0x27190
leaq 0x10(%rax), %rbx
movq $0x6, (%rax)
movq $0x4, 0x8(%rax)
addq $0x4, %r14
leaq 0x1a0(%rsp), %rcx
movl $0x0, (%rcx)
leaq 0x20(%rsp), %rdi
movq %r14, -0x8(%rdi)
le... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void IteratorTest::accessIteratorOperations<true>() | void IteratorTest::accessIteratorOperations() {
// operator*
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::Iterator<int, constTarget> it;
it = v.begin();
for(int i = 0; i <... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x160, %rsp # imm = 0x160
movq %rdi, %rbx
movl $0x8, %edi
callq 0x27190
movq %rax, %r14
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
leaq 0xa8(%rsp), %rdi
movq %rbx, -0x8(%rdi)
leaq 0x7685e(%rip), %rcx # 0x1385e0
leaq 0x30(%rsp), %r9
movq %rax, %rsi... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void IteratorTest::arithmeticOperatorsTest<false>() | void IteratorTest::arithmeticOperatorsTest(){
// operator+=
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::Iterator<int, constTarget> it;
it = v.begin();
for(int i = 0; i < ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, %r14
movl $0x8, %edi
callq 0x27190
movq %rax, %rbx
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
leaq 0x68(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0x74bf4(%rip), %rcx # 0x1385e0
movq %rsp, %r9
movq %rax,... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void IteratorTest::arithmeticOperatorsTest<true>() | void IteratorTest::arithmeticOperatorsTest(){
// operator+=
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::Iterator<int, constTarget> it;
it = v.begin();
for(int i = 0; i < ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, %r14
movl $0x8, %edi
callq 0x27190
movq %rax, %rbx
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
leaq 0x68(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0x70a46(%rip), %rcx # 0x1385e0
movq %rsp, %r9
movq %rax,... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void IteratorTest::comparisonOperators<false>() | void IteratorTest::comparisonOperators(){
// operator-
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::Iterator<int, constTarget> it1;
andres::Iterator<int, constTarget> it2;
it1 = v.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %r14
movl $0x8, %edi
callq 0x27190
movq %rax, %rbx
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
leaq 0x98(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0x6c699(%rip), %rcx # 0x1385e0
leaq 0x30(%rsp), %r9
movq... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void IteratorTest::comparisonOperators<true>() | void IteratorTest::comparisonOperators(){
// operator-
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::Iterator<int, constTarget> it1;
andres::Iterator<int, constTarget> it2;
it1 = v.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %r14
movl $0x8, %edi
callq 0x27190
movq %rax, %rbx
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
leaq 0x98(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0x67457(%rip), %rcx # 0x1385e0
leaq 0x30(%rsp), %r9
movq... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void IteratorTest::hasMoreTest<false>() | void IteratorTest::hasMoreTest() {
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::Iterator<int, constTarget> it;
it = v.begin();
for(int i = 0; i < 24; ++i){
test(it.hasMore... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r15
movl $0x8, %edi
callq 0x27190
movq %rax, %rbx
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
leaq 0x68(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x61f58(%rip), %rcx # 0x1385e0
movq %rsp, %r9
movq %rax, %rsi
movq %rcx, %r8
callq 0xea8ec
le... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void IteratorTest::hasMoreTest<true>() | void IteratorTest::hasMoreTest() {
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::Iterator<int, constTarget> it;
it = v.begin();
for(int i = 0; i < 24; ++i){
test(it.hasMore... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r14
movl $0x8, %edi
callq 0x27190
movq %rax, %rbx
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
leaq 0x68(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0x617c0(%rip), %rcx # 0x1385e0
movq %rsp, %r9
movq %rax, %rsi
movq %rcx, %r8
callq 0xea8ec
leaq 0x60(%rs... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void IteratorTest::indexTest<false>() | void IteratorTest::indexTest() {
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::Iterator<int, constTarget> it;
it = v.begin();
for(int i = 0; i < 24; ++i){
test(it.index()==... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r14
movl $0x8, %edi
callq 0x27190
movq %rax, %rbx
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
leaq 0x68(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0x61023(%rip), %rcx # 0x1385e0
movq %rsp, %r9
movq %rax, %rsi
movq %rcx, %r8
callq 0xea8ec
le... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void IteratorTest::indexTest<true>() | void IteratorTest::indexTest() {
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::Iterator<int, constTarget> it;
it = v.begin();
for(int i = 0; i < 24; ++i){
test(it.index()==... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r14
movl $0x8, %edi
callq 0x27190
movq %rax, %rbx
leaq 0x8(%rax), %rdx
movq $0x18, (%rax)
leaq 0x68(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0x60aa1(%rip), %rcx # 0x1385e0
movq %rsp, %r9
movq %rax, %rsi
movq %rcx, %r8
callq 0xea8ec
leaq 0x60(%rs... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void IteratorTest::coordinateTest<false>() | void IteratorTest::coordinateTest() {
{
std::vector<std::size_t> shape(2);
shape[0] = 3;
shape[1] = 8;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::Iterator<int, constTarget> it(v, 0);
for(std::size_t y=0; y<8; ++y) {
for(s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
movl $0x10, %edi
callq 0x27190
movq %rax, %rbx
leaq 0x10(%rax), %rdx
movq $0x3, (%rax)
movq $0x8, 0x8(%rax)
leaq 0x40(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0x60503(%rip), %rcx # 0x1385e0
leaq 0x8(%rsp), %r9
movq %rax... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void IteratorTest::coordinateTest<true>() | void IteratorTest::coordinateTest() {
{
std::vector<std::size_t> shape(2);
shape[0] = 3;
shape[1] = 8;
andres::View<int, constTarget> v(shape.begin(), shape.end(), data_);
andres::Iterator<int, constTarget> it(v, 0);
for(std::size_t y=0; y<8; ++y) {
for(s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
movl $0x10, %edi
callq 0x27190
movq %rax, %rbx
leaq 0x10(%rax), %rdx
movq $0x3, (%rax)
movq $0x8, 0x8(%rax)
leaq 0x40(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0x600d3(%rip), %rcx # 0x1385e0
leaq 0x8(%rsp), %r9
movq %rax... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void MarrayTest::copyConstructorTest<false>() | void MarrayTest::copyConstructorTest() {
// contruction from a Marray
{
// empty
{
andres::Marray<int> m;
andres::Marray<int> n(m);
}
// scalar
{
andres::Marray<int> m(scalar_);
andres::Marray<int> n(m);
test(m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
xorl %eax, %eax
leaq 0x68(%rsp), %rdi
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c(%rdi)
callq 0xe9fe4
leaq 0x68(... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void MarrayTest::copyConstructorTest<true>() | void MarrayTest::copyConstructorTest() {
// contruction from a Marray
{
// empty
{
andres::Marray<int> m;
andres::Marray<int> n(m);
}
// scalar
{
andres::Marray<int> m(scalar_);
andres::Marray<int> n(m);
test(m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
xorl %eax, %eax
leaq 0x68(%rsp), %rdi
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c(%rdi)
callq 0xe9fe4
leaq 0x68(... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void MarrayTest::assignmentOperatorTest<false>() | void MarrayTest::assignmentOperatorTest(){
// empty
{
// from a Marray
{
// empty
{
andres::Marray<int> m;
andres::Marray<int> n;
n = m;
}
// scalar
{
andres::Marray<int> m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r12
xorl %eax, %eax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c(%rdi)
callq 0xe9fe4
leaq 0x10(%rsp),... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void MarrayTest::assignmentOperatorTest<true>() | void MarrayTest::assignmentOperatorTest(){
// empty
{
// from a Marray
{
// empty
{
andres::Marray<int> m;
andres::Marray<int> n;
n = m;
}
// scalar
{
andres::Marray<int> m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r12
xorl %eax, %eax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c(%rdi)
callq 0xe9fe4
leaq 0x10(%rsp),... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void MarrayTest::resizeTest<(andres::CoordinateOrder)1>() | void MarrayTest::resizeTest() {
// 1D
{
// shrink
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::Marray<int> m(shape.begin(), shape.end(), scalar_, coordinateOrder);
shape[0] = 12;
m.resize(shape.begin(), shape.end(), 12)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movl $0x8, %edi
callq 0x27190
movq %rax, %r14
leaq 0x8(%rax), %r15
movq $0x18, (%rax)
movq %rsp, %r8
movl $0x1, (%r8)
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %r9
movq %rax, %rsi
movq %r15, %rdx
movq %rbx, 0x8(%rsp)
movq %rb... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
void MarrayTest::resizeTest<(andres::CoordinateOrder)0>() | void MarrayTest::resizeTest() {
// 1D
{
// shrink
{
std::vector<std::size_t> shape(1);
shape[0] = 24;
andres::Marray<int> m(shape.begin(), shape.end(), scalar_, coordinateOrder);
shape[0] = 12;
m.resize(shape.begin(), shape.end(), 12)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movl $0x8, %edi
callq 0x27190
movq %rax, %r14
leaq 0x8(%rax), %r15
movq $0x18, (%rax)
movq %rsp, %r8
movl $0x0, (%r8)
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %r9
movq %rax, %rsi
movq %r15, %rdx
movq %rbx, 0x8(%rsp)
movq %rb... | /bjoern-andres[P]marray/src/unittest/marray.cxx |
andres::View<int, false, std::allocator<unsigned long>>::testInvariant() const | inline const std::size_t
Geometry<A>::dimension() const
{
return dimension_;
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xea048
cmpq $0x0, (%rdi)
je 0xea129
movq 0x10(%rdi), %rcx
movl $0x1, %edx
xorl %esi, %esi
imulq (%rcx,%rsi,8), %rdx
incq %rsi
cmpq %rsi, %rax
jne 0xea006
cmpq %rdx, 0x30(%rdi)
jne 0xea147
cmpl $0x0, 0x38(%rdi)
movq 0x18(%rdi), %rdx
movl $0x1, %... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, false, std::allocator<unsigned long>>::reference andres::marray_detail::AccessOperatorHelper<true>::execute<int, int, false, std::allocator<unsigned long>>(andres::View<int, false, std::allocator<unsigned long>> const&, int const&) | static typename View<T, isConst, A>::reference
execute(const View<T, isConst, A>& v, const U& index)
{
v.testInvariant();
Assert(MARRAY_NO_DEBUG || v.data_ != 0);
Assert(MARRAY_NO_DEBUG || v.dimension() != 0 || index == 0);
std::size_t offset;
v.indexToOffset(index, offse... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xe9fe4
cmpq $0x0, (%rbx)
je 0xea1ee
cmpq $0x0, 0x28(%rbx)
setne %cl
movl (%r14), %eax
testl %eax, %eax
sete %dl
orb %cl, %dl
je 0xea20c
movslq %eax, %rsi
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xea254
movq (%r14), %rax
shlq $0x2, %ra... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, true, std::allocator<unsigned long>>::testInvariant() const | inline const std::size_t
Geometry<A>::dimension() const
{
return dimension_;
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xea4cc
cmpq $0x0, (%rdi)
je 0xea5ad
movq 0x10(%rdi), %rcx
movl $0x1, %edx
xorl %esi, %esi
imulq (%rcx,%rsi,8), %rdx
incq %rsi
cmpq %rsi, %rax
jne 0xea48a
cmpq %rdx, 0x30(%rdi)
jne 0xea5cb
cmpl $0x0, 0x38(%rdi)
movq 0x18(%rdi), %rdx
movl $0x1, %... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, true, std::allocator<unsigned long>>::reference andres::marray_detail::AccessOperatorHelper<true>::execute<int, int, true, std::allocator<unsigned long>>(andres::View<int, true, std::allocator<unsigned long>> const&, int const&) | static typename View<T, isConst, A>::reference
execute(const View<T, isConst, A>& v, const U& index)
{
v.testInvariant();
Assert(MARRAY_NO_DEBUG || v.data_ != 0);
Assert(MARRAY_NO_DEBUG || v.dimension() != 0 || index == 0);
std::size_t offset;
v.indexToOffset(index, offse... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xea468
cmpq $0x0, (%rbx)
je 0xea672
cmpq $0x0, 0x28(%rbx)
setne %cl
movl (%r14), %eax
testl %eax, %eax
sete %dl
orb %cl, %dl
je 0xea690
movslq %eax, %rsi
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xea6d8
movq (%r14), %rax
shlq $0x2, %ra... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, true, std::allocator<unsigned long>>::indexToOffset(unsigned long, unsigned long&) const | inline void
View<T, isConst, A>::indexToOffset
(
std::size_t index,
std::size_t& out
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_ARG_TEST || index < this->size());
if(isSimple()) {
out = index;
}
else {
out = 0;
if(coordinateOrder() == FirstMajorOrder)... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xea468
cmpq %r15, 0x30(%r14)
jbe 0xea861
movq %r14, %rdi
callq 0xea468
cmpb $0x1, 0x3c(%r14)
jne 0xea70d
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0xea468
cmpl $0x0, 0x38(%r14)
movq... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::Geometry<std::allocator<unsigned long>>::Geometry<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, __gnu_cxx::__normal_iterator<unsigned... | inline
Geometry<A>::Geometry
(
ShapeIterator begin,
ShapeIterator end,
const CoordinateOrder& externalCoordinateOrder,
const CoordinateOrder& internalCoordinateOrder,
const typename Geometry<A>::allocator_type& allocator
)
: allocator_(allocator),
shape_(allocator_.allocate(std::distance(begin, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rbp
subq %rsi, %rbp
sarq $0x3, %rbp
leaq (,%rbp,2), %rsi
addq %rbp, %rsi
xorl %edx, %edx
callq 0xe9f74
movq %r14, %rcx
movq %rax, 0x8(%rbx)
subq %r15, %... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, false, std::allocator<unsigned long>>::strides(unsigned long) const | inline const std::size_t
View<T, isConst, A>::strides
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.strides(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe9fe4
cmpq $0x0, (%r14)
je 0xeab0f
cmpq %rbx, 0x28(%r14)
jbe 0xeab2d
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0x4e01f(%rip), %rsi # 0x138b42
mov... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, true, std::allocator<unsigned long>>::strides(unsigned long) const | inline const std::size_t
View<T, isConst, A>::strides
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.strides(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xea468
cmpq $0x0, (%r14)
je 0xeab9f
cmpq %rbx, 0x28(%r14)
jbe 0xeabbd
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0x4df8f(%rip), %rsi # 0x138b42
mov... | /bjoern-andres[P]marray/include/andres/marray.hxx |
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.