idx
int64 0
2.11M
| name
stringlengths 1
118k
| code
stringlengths 6
516k
| asm
stringlengths 21
4.64M
| file
stringlengths 39
143
| opt
stringclasses 1
value | path
stringlengths 20
133
|
|---|---|---|---|---|---|---|
6,000 | Omega_h::InputScalar::as(int&) const | bool InputScalar::as(int& out) const {
std::istringstream ss(str);
using LL = long long;
LL val;
ss >> std::noskipws >> val;
if (ss.eof() && !ss.fail() && (val >= LL(std::numeric_limits<int>::min())) &&
(val <= LL(std::numeric_limits<int>::max()))) {
out = int(val);
return true;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
movl $0x8, %edx
callq 0x1ddb40
movq -0x1c0(%rbp), %rdi
movq 0x35afef(%rip), %rsi # 0x6f7920
callq 0x1dd650
movq %rax, -0x1b8(%rbp)
jmp 0x39c93f
movq -0x1b8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x1d2130
jmp 0x39c954
movq -0x198(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x198(%rbp,%rax), %rdi
callq 0x1e16e0
movb %al, -0x1c1(%rbp)
jmp 0x39c974
movb -0x1c1(%rbp), %al
testb $0x1, %al
jne 0x39c983
jmp 0x39ca3a
movq -0x198(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x198(%rbp,%rax), %rdi
callq 0x1b81a0
movb %al, -0x1c2(%rbp)
jmp 0x39c9a3
movb -0x1c2(%rbp), %al
testb $0x1, %al
jne 0x39ca3a
jmp 0x39c9b3
movq -0x1a0(%rbp), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1c6920
movl %eax, %ecx
movq -0x1d0(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x39ca3a
movq -0x1a0(%rbp), %rax
movq %rax, -0x1d8(%rbp)
callq 0x1c8c80
movl %eax, %ecx
movq -0x1d8(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jg 0x39ca3a
movq -0x1a0(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x1b0(%rbp)
jmp 0x39ca48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x1c0700
jmp 0x39ca62
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1b0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x1c0700
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1e0, %rsp # imm = 0x1E0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,001 | Omega_h::InputScalar::as(long long&) const | bool InputScalar::as(long long& out) const {
std::istringstream ss(str);
ss >> std::noskipws >> out;
return ss.eof() && !ss.fail();
} | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
movl $0x8, %edx
callq 0x1ddb40
movq -0x1b0(%rbp), %rdi
movq 0x35ae6f(%rip), %rsi # 0x6f7920
callq 0x1dd650
movq %rax, -0x1a8(%rbp)
jmp 0x39cabf
movq -0x1a8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d2130
jmp 0x39cad1
movq -0x190(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x190(%rbp,%rax), %rdi
callq 0x1e16e0
movb %al, -0x1b1(%rbp)
jmp 0x39caf1
movb -0x1b1(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1b2(%rbp)
jne 0x39cb06
jmp 0x39cb34
movq -0x190(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x190(%rbp,%rax), %rdi
callq 0x1b81a0
movb %al, -0x1b3(%rbp)
jmp 0x39cb26
movb -0x1b3(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1b2(%rbp)
movb -0x1b2(%rbp), %al
movb %al, -0x1b4(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x1c0700
movb -0x1b4(%rbp), %al
andb $0x1, %al
addq $0x1c0, %rsp # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x1c0700
movq -0x198(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,002 | Omega_h::Input::Input() | Input::Input() : parent(nullptr), used(false) {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x35b09d(%rip), %rcx # 0x6f7c40
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,003 | Omega_h::Input::out_of_line_virtual_method() | void Input::out_of_line_virtual_method() {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,004 | Omega_h::InputList::position(Omega_h::Input const&) | LO InputList::position(Input const& input) {
auto it = std::find_if(entries.begin(), entries.end(),
[&](std::shared_ptr<Input> const& sptr) { return sptr.get() == &input; });
OMEGA_H_CHECK(it != entries.end());
return LO(it - entries.begin());
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x18, %rdi
callq 0x1ce400
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x1b93e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x39d4b0
movq -0x48(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x18, %rdi
callq 0x1b93e0
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1d4a80
testb $0x1, %al
jne 0x39cc47
jmp 0x39cc49
jmp 0x39cc6a
leaq 0x28e418(%rip), %rdi # 0x62b068
leaq 0x295b5d(%rip), %rsi # 0x6327b4
leaq 0x295aca(%rip), %rdx # 0x632728
movl $0x10a, %ecx # imm = 0x10A
movb $0x0, %al
callq 0x1ce550
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x1ce400
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1e2200
addq $0x50, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,005 | Omega_h::InputMap::name[abi:cxx11](Omega_h::Input const&) | std::string const& InputMap::name(Input const& input) {
for (auto& pair : map) {
if (pair.second.get() == &input) return pair.first;
}
OMEGA_H_NORETURN(map.end()->first);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b9c30
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c5050
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1d94b0
testb $0x1, %al
jne 0x39ccd9
jmp 0x39cd10
leaq -0x20(%rbp), %rdi
callq 0x1bb1a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x1e3fe0
cmpq -0x10(%rbp), %rax
jne 0x39cd03
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
jmp 0x39cd05
leaq -0x20(%rbp), %rdi
callq 0x1cf8a0
jmp 0x39ccc6
leaq 0x28e351(%rip), %rdi # 0x62b068
leaq 0x28ea4b(%rip), %rsi # 0x62b769
leaq 0x295a03(%rip), %rdx # 0x632728
movl $0xf5, %ecx
movb $0x0, %al
callq 0x1ce550
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,006 | Omega_h::InputScalar::InputScalar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | InputScalar::InputScalar(std::string const& str_in) : str(str_in) {} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1c9a60
movq -0x28(%rbp), %rdi
movq 0x35b1e0(%rip), %rax # 0x6f7f48
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x1c00c0
jmp 0x39cd7e
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1e3050
movq -0x18(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,007 | Omega_h::InputScalar::out_of_line_virtual_method() | void InputScalar::out_of_line_virtual_method() {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,008 | Omega_h::InputMapIterator::InputMapIterator(std::_Rb_tree_const_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<Omega_h::Input>>>) | InputMapIterator::InputMapIterator(decltype(impl) impl_in) : impl(impl_in) {} | pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,009 | Omega_h::InputMapIterator::operator==(Omega_h::InputMapIterator const&) const | bool InputMapIterator::operator==(InputMapIterator const& other) const
noexcept {
return impl == other.impl;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d6930
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,010 | Omega_h::InputMapIterator::operator!=(Omega_h::InputMapIterator const&) const | bool InputMapIterator::operator!=(InputMapIterator const& other) const
noexcept {
return impl != other.impl;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d3db0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,011 | Omega_h::InputMapIterator::operator*[abi:cxx11]() const | InputMapIterator::reference InputMapIterator::operator*() const noexcept {
return impl->first;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dd900
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,012 | Omega_h::InputMapIterator::operator->[abi:cxx11]() const | InputMapIterator::pointer InputMapIterator::operator->() const noexcept {
return &(impl->first);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dd900
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,013 | Omega_h::InputMapIterator::operator++() | InputMapIterator& InputMapIterator::operator++() noexcept {
++impl;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1c7b90
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,014 | Omega_h::InputMapIterator::operator++(int) | InputMapIterator InputMapIterator::operator++(int) noexcept { return impl++; } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1e4210
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d86a0
jmp 0x39cedd
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,015 | Omega_h::InputMapIterator::operator--() | InputMapIterator& InputMapIterator::operator--() noexcept {
--impl;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1c17a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,016 | Omega_h::InputMapIterator::operator--(int) | InputMapIterator InputMapIterator::operator--(int) noexcept { return impl--; } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1d2c70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d86a0
jmp 0x39cf4d
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,017 | Omega_h::InputMap::InputMap(Omega_h::InputMap&&) | InputMap::InputMap(InputMap&& other) : Input(other), map(std::move(other.map)) {
for (auto& pair : map) (pair.second)->parent = this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c3ef0
movq -0x38(%rbp), %rdi
movq 0x35aedc(%rip), %rax # 0x6f7e68
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x1de6c0
movq -0x38(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b9c30
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c5050
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1d94b0
testb $0x1, %al
jne 0x39cfdd
jmp 0x39d00a
leaq -0x20(%rbp), %rdi
callq 0x1bb1a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x1cab20
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
leaq -0x20(%rbp), %rdi
callq 0x1cf8a0
jmp 0x39cfca
addq $0x40, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,018 | Omega_h::InputMap::InputMap(Omega_h::InputMap const&) | InputMap::InputMap(InputMap const& other) : Input(other) {
Omega_h_fail("InputMap should never actually be copied!\n");
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c3ef0
movq -0x30(%rbp), %rdi
movq 0x35ae2c(%rip), %rax # 0x6f7e68
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x28(%rbp)
callq 0x1c18f0
leaq 0x29563e(%rip), %rdi # 0x632695
xorl %eax, %eax
callq 0x1ce550
jmp 0x39d060
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1dbbf0
movq -0x30(%rbp), %rdi
callq 0x1e3050
movq -0x18(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,019 | Omega_h::InputMap::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<Omega_h::Input>&&) | void InputMap::add(std::string const& name, std::shared_ptr<Input>&& input) {
input->parent = this;
auto const did = map.emplace(name, std::move(input)).second;
if (!did) {
fail("tried to add already existing InputMap name \"%s\"\n", name.c_str());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1cab20
movq -0x48(%rbp), %rdi
movq %rdi, 0x8(%rax)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1da860
movb %dl, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movb -0x38(%rbp), %al
movb %al, -0x28(%rbp)
movb -0x28(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x39d10b
movq -0x10(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rsi
leaq 0x2955bc(%rip), %rdi # 0x6326c0
movb $0x0, %al
callq 0x1ce550
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,020 | Omega_h::InputMap::is_map(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool InputMap::is_map(std::string const& name) {
return this->is_input<InputMap>(name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d3100
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,021 | Omega_h::InputMap::is_list(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool InputMap::is_list(std::string const& name) {
return this->is_input<InputList>(name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d6b70
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,022 | Omega_h::InputMap::get_map(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | InputMap& InputMap::get_map(std::string const& name) {
if (!is_map(name)) {
std::shared_ptr<Input> sptr(new InputMap());
this->add(name, std::move(sptr));
}
return this->use_input<InputMap>(name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1dac80
testb $0x1, %al
jne 0x39d240
movl $0x48, %edi
callq 0x1cd9b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x40(%rdi)
callq 0x1cdb80
jmp 0x39d1de
movq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1cff90
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x10(%rbp), %rsi
callq 0x1c09b0
jmp 0x39d202
leaq -0x20(%rbp), %rdi
callq 0x1dd210
jmp 0x39d240
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x48, %esi
callq 0x1ce050
jmp 0x39d253
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1dd210
jmp 0x39d253
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d6d70
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,023 | Omega_h::InputMap::get_list(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | InputList& InputMap::get_list(std::string const& name) {
if (!is_list(name)) {
std::shared_ptr<Input> sptr(new InputList());
this->add(name, std::move(sptr));
}
return this->use_input<InputList>(name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d64b0
testb $0x1, %al
jne 0x39d314
movl $0x30, %edi
callq 0x1cd9b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x1bb980
jmp 0x39d2b2
movq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1c8240
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x10(%rbp), %rsi
callq 0x1c09b0
jmp 0x39d2d6
leaq -0x20(%rbp), %rdi
callq 0x1dd210
jmp 0x39d314
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x1ce050
jmp 0x39d327
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1dd210
jmp 0x39d327
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1beaf0
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x1dfa40
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,024 | Omega_h::InputMap::out_of_line_virtual_method() | void InputMap::out_of_line_virtual_method() {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,025 | Omega_h::InputList::InputList(Omega_h::InputList&&) | InputList::InputList(InputList&& other) : entries(std::move(other.entries)) {
for (auto& sptr : entries) sptr->parent = this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1c9a60
movq -0x38(%rbp), %rdi
movq 0x35a6f8(%rip), %rax # 0x6f7a60
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x1be1f0
movq -0x38(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ce400
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b93e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1d4a80
testb $0x1, %al
jne 0x39d3b9
jmp 0x39d3e2
leaq -0x20(%rbp), %rdi
callq 0x1bcef0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1cab20
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
leaq -0x20(%rbp), %rdi
callq 0x1da6f0
jmp 0x39d3a6
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,026 | Omega_h::InputList::InputList(Omega_h::InputList const&) | InputList::InputList(InputList const& other) : Input(other) {
Omega_h_fail("InputList should never actually be copied!\n");
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c3ef0
movq -0x30(%rbp), %rdi
movq 0x35a644(%rip), %rax # 0x6f7a60
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x28(%rbp)
callq 0x1bff20
leaq 0x295351(%rip), %rdi # 0x632788
xorl %eax, %eax
callq 0x1ce550
jmp 0x39d440
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1da920
movq -0x30(%rbp), %rdi
callq 0x1e3050
movq -0x18(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,027 | Omega_h::InputList::add(std::shared_ptr<Omega_h::Input>&&) | void InputList::add(std::shared_ptr<Input>&& input) {
input->parent = this;
entries.push_back(std::move(input));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1cab20
movq -0x18(%rbp), %rdi
movq %rdi, 0x8(%rax)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x1ba570
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,028 | Omega_h::InputList::size() | LO InputList::size() { return LO(entries.size()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x1dc2a0
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,029 | Omega_h::InputList::is_map(int) | bool InputList::is_map(LO i) { return this->is_input<InputMap>(i); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1d7a90
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,030 | Omega_h::InputList::is_list(int) | bool InputList::is_list(LO i) { return this->is_input<InputList>(i); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1dbd20
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,031 | Omega_h::InputList::get_map(int) | InputMap& InputList::get_map(LO i) { return this->use_input<InputMap>(i); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c1840
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,032 | Omega_h::InputList::get_list(int) | InputList& InputList::get_list(LO i) { return this->use_input<InputList>(i); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1d58f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,033 | Omega_h::InputList::out_of_line_virtual_method() | void InputList::out_of_line_virtual_method() {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,034 | Omega_h::InputMap::begin() const | InputMapIterator InputMap::begin() const noexcept { return map.begin(); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x1cf880
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d86a0
jmp 0x39d62c
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,035 | Omega_h::InputMap::end() const | InputMapIterator InputMap::end() const noexcept { return map.end(); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x1beac0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d86a0
jmp 0x39d66c
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,036 | Omega_h::InputMap::remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void InputMap::remove(std::string const& name) {
auto const it = map.find(name);
if (it == map.end())
Omega_h_fail("InputMap::remove: \"%s\" didn't exist\n", name.c_str());
map.erase(it);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x1bef10
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x18, %rdi
callq 0x1c5050
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1c5950
testb $0x1, %al
jne 0x39d6cd
jmp 0x39d6e7
movq -0x10(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rsi
leaq 0x2950e8(%rip), %rdi # 0x6327c8
movb $0x0, %al
callq 0x1ce550
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x1dda20
movq %rax, -0x30(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,037 | Omega_h::InputYamlReader::~InputYamlReader() | InputYamlReader::~InputYamlReader() {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1da040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,038 | Omega_h::InputYamlReader::~InputYamlReader() | InputYamlReader::~InputYamlReader() {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1c9460
movq -0x10(%rbp), %rdi
movl $0x198, %esi # imm = 0x198
callq 0x1ce050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,039 | Omega_h::read_input(Omega_h::filesystem::path const&) | InputMap read_input(Omega_h::filesystem::path const& path) {
OMEGA_H_TIME_FUNCTION;
InputMap map = read_input_without_includes(path);
while (handle_one_include(map))
;
return map;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x1dfbb0
movq -0xc0(%rbp), %rdx
leaq 0x294f86(%rip), %rsi # 0x632728
leaq -0x78(%rbp), %rdi
callq 0x1d5e00
jmp 0x39d7ad
leaq 0x28dac1(%rip), %rdx # 0x62b275
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1bb5a0
jmp 0x39d7c3
leaq -0xb0(%rbp), %rdi
movl $0x39c, %esi # imm = 0x39C
callq 0x1d4960
jmp 0x39d7d6
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x1ca480
jmp 0x39d7ec
leaq -0x38(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0x294fee(%rip), %rsi # 0x6327ed
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
jmp 0x39d80a
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
leaq -0xb0(%rbp), %rdi
callq 0x1c4d10
leaq -0x58(%rbp), %rdi
callq 0x1c4d10
leaq -0x78(%rbp), %rdi
callq 0x1c4d10
leaq -0x79(%rbp), %rdi
callq 0x1cf450
movq -0xd0(%rbp), %rdi
movb $0x0, -0xb1(%rbp)
movq -0x10(%rbp), %rsi
callq 0x39d990
jmp 0x39d853
jmp 0x39d855
movq -0xd0(%rbp), %rdi
callq 0x39db50
movb %al, -0xd1(%rbp)
jmp 0x39d869
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x39d878
jmp 0x39d942
jmp 0x39d855
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x39d903
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x39d8fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x39d8f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x39d8e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
leaq -0xb0(%rbp), %rdi
callq 0x1c4d10
leaq -0x58(%rbp), %rdi
callq 0x1c4d10
leaq -0x78(%rbp), %rdi
callq 0x1c4d10
leaq -0x79(%rbp), %rdi
callq 0x1cf450
jmp 0x39d980
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x39d977
movq -0xd0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
callq 0x1db760
jmp 0x39d977
movb $0x1, -0xb1(%rbp)
testb $0x1, -0xb1(%rbp)
jne 0x39d95e
movq -0xd0(%rbp), %rdi
callq 0x1db760
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
movq -0xc8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,040 | Omega_h::read_input_without_includes(Omega_h::filesystem::path const&) | static InputMap read_input_without_includes(
Omega_h::filesystem::path const& path) {
std::ifstream stream(path.c_str());
if (!stream.is_open()) {
Omega_h_fail("Couldn't open Input file \"%s\"\n", path.c_str());
}
Omega_h::InputYamlReader reader;
auto result_any = reader.read_stream(stream, path.string());
return any_cast<InputMap&&>(std::move(result_any));
} | pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp # imm = 0x420
movq %rdi, -0x418(%rbp)
movq %rdi, %rax
movq %rax, -0x410(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b9690
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movq %rdi, -0x408(%rbp)
movl $0x8, %edx
callq 0x1e12d0
movq -0x408(%rbp), %rdi
callq 0x1dbaf0
movb %al, -0x3f9(%rbp)
jmp 0x39d9ec
movb -0x3f9(%rbp), %al
testb $0x1, %al
jne 0x39da2b
jmp 0x39d9f8
movq -0x10(%rbp), %rdi
callq 0x1b9690
movq %rax, %rsi
leaq 0x294e32(%rip), %rdi # 0x63283d
xorl %eax, %eax
callq 0x1ce550
jmp 0x39da14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x39db36
leaq -0x3c0(%rbp), %rdi
callq 0x1ddb80
jmp 0x39da39
movq -0x10(%rbp), %rsi
leaq -0x3f8(%rbp), %rdi
callq 0x1d5bc0
jmp 0x39da4b
leaq -0x3d8(%rbp), %rdi
leaq -0x3c0(%rbp), %rsi
leaq -0x218(%rbp), %rdx
leaq -0x3f8(%rbp), %rcx
callq 0x1c0510
jmp 0x39da6e
leaq -0x3f8(%rbp), %rdi
callq 0x1c4d10
leaq -0x3d8(%rbp), %rdi
callq 0x1dd290
movq %rax, -0x420(%rbp)
jmp 0x39da8f
movq -0x420(%rbp), %rsi
movq -0x418(%rbp), %rdi
callq 0x1d79a0
jmp 0x39daa4
leaq -0x3d8(%rbp), %rdi
callq 0x1cd2d0
leaq -0x3c0(%rbp), %rdi
callq 0x1c9460
leaq -0x218(%rbp), %rdi
callq 0x1bbe70
movq -0x410(%rbp), %rax
addq $0x420, %rsp # imm = 0x420
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x39db2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x3f8(%rbp), %rdi
callq 0x1c4d10
jmp 0x39db2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x3d8(%rbp), %rdi
callq 0x1cd2d0
leaq -0x3c0(%rbp), %rdi
callq 0x1c9460
leaq -0x218(%rbp), %rdi
callq 0x1bbe70
movq -0x220(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,041 | Omega_h::handle_one_include(Omega_h::InputMap&) | static bool handle_one_include(InputMap& map) {
for (auto& key : map) {
if (key == "include") {
auto const path = map.get<std::string>(key);
map.remove(key);
auto included_map = read_input_without_includes(path);
while (!included_map.map.empty()) {
auto const it = included_map.map.begin();
map.add(it->first, std::move(it->second));
included_map.map.erase(it);
}
return true;
} else if (map.is_list(key)) {
if (handle_one_include(map.get_list(key))) return true;
} else if (map.is_map(key)) {
if (handle_one_include(map.get_map(key))) return true;
}
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1dce20
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1cd200
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1d72c0
testb $0x1, %al
jne 0x39db97
jmp 0x39ddb6
leaq -0x20(%rbp), %rdi
callq 0x1c89e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x294cad(%rip), %rsi # 0x63285c
callq 0x1e4c20
testb $0x1, %al
jne 0x39dbbd
jmp 0x39dd36
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x1c78c0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1ddfe0
jmp 0x39dbdd
leaq -0xc8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1dc480
jmp 0x39dbef
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x39d990
jmp 0x39dc04
leaq -0xc8(%rbp), %rdi
callq 0x1b9420
leaq -0xa8(%rbp), %rdi
addq $0x18, %rdi
callq 0x1da750
xorb $-0x1, %al
testb $0x1, %al
jne 0x39dc2b
jmp 0x39dd0a
leaq -0x90(%rbp), %rdi
callq 0x1b9c30
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xd0(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1df480
movq -0xf8(%rbp), %rdi
movq %rax, -0xe8(%rbp)
callq 0x1df480
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movq %rax, %rdx
addq $0x20, %rdx
callq 0x1c09b0
jmp 0x39dc8b
leaq -0x90(%rbp), %rdi
movq -0xd0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rsi
callq 0x1dda20
movq %rax, -0x100(%rbp)
jmp 0x39dcb5
movq -0x100(%rbp), %rax
movq %rax, -0xe0(%rbp)
jmp 0x39dc10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x39dd28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x1b9420
jmp 0x39dd28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1db760
jmp 0x39dd28
movb $0x1, -0x1(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1db760
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
jmp 0x39ddba
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
jmp 0x39ddc8
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1d64b0
testb $0x1, %al
jne 0x39dd49
jmp 0x39dd6c
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1b84e0
movq %rax, %rdi
callq 0x39e460
testb $0x1, %al
jne 0x39dd64
jmp 0x39dd6a
movb $0x1, -0x1(%rbp)
jmp 0x39ddba
jmp 0x39dda4
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1dac80
testb $0x1, %al
jne 0x39dd7f
jmp 0x39dda2
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1ca1e0
movq %rax, %rdi
callq 0x39db50
testb $0x1, %al
jne 0x39dd9a
jmp 0x39dda0
movb $0x1, -0x1(%rbp)
jmp 0x39ddba
jmp 0x39dda2
jmp 0x39dda4
jmp 0x39dda6
jmp 0x39dda8
leaq -0x20(%rbp), %rdi
callq 0x1bcc20
jmp 0x39db81
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,042 | Omega_h::update_class_sets(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>*, Omega_h::InputMap&) | void update_class_sets(ClassSets* p_sets, InputMap& pl) {
ClassSets& sets = *p_sets;
for (auto& set_name : pl) {
auto& pairs = pl.get_list(set_name);
auto npairs = pairs.size();
for (decltype(npairs) i = 0; i < npairs; ++i) {
auto& pair = pairs.get_list(i);
if (pair.size() != 2) {
Omega_h_fail(
"Expected \"%s\" to be an array of int pairs\n", set_name.c_str());
}
auto class_dim = Int(pair.get<int>(0));
auto class_id = LO(pair.get<int>(1));
sets[set_name].push_back({class_dim, class_id});
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1dce20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1cd200
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1d72c0
testb $0x1, %al
jne 0x39de30
jmp 0x39df0f
leaq -0x28(%rbp), %rdi
callq 0x1c89e0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1b84e0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1bc3c0
movl %eax, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x39deff
movq -0x40(%rbp), %rdi
movl -0x48(%rbp), %esi
callq 0x1bde10
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1bc3c0
cmpl $0x2, %eax
je 0x39dea5
movq -0x38(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rsi
leaq 0x29495a(%rip), %rdi # 0x6327f8
movb $0x0, %al
callq 0x1ce550
movq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x1e4a60
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0x1e4a60
movl %eax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1cd990
movq %rax, -0x68(%rbp)
movl -0x54(%rbp), %esi
movl -0x58(%rbp), %edx
leaq -0x60(%rbp), %rdi
callq 0x1cdbe0
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c97f0
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x39de61
jmp 0x39df01
leaq -0x28(%rbp), %rdi
callq 0x1bcc20
jmp 0x39de1a
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,043 | Omega_h::echo_input(std::ostream&, Omega_h::Input&) | void echo_input(std::ostream& stream, Input& input) {
echo_input_recursive(stream, input, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x39df50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,044 | Omega_h::echo_input_recursive(std::ostream&, Omega_h::Input&, int) | static void echo_input_recursive(
std::ostream& stream, Input& input, Int indent) {
if (is_type<InputScalar>(input)) {
auto& scalar = as_type<InputScalar>(input);
if (std::find(scalar.str.begin(), scalar.str.end(), '\n') !=
scalar.str.end()) {
stream << " |\n";
for (auto c : scalar.str) {
if (c == '\n') {
for (Int i = 0; i < indent; ++i) {
stream << " ";
}
}
stream << c;
}
} else {
stream << " \'" << scalar.str << '\'';
}
} else if (is_type<InputMap>(input)) {
auto& map = as_type<InputMap>(input);
stream << '\n';
for (auto& pair : map.map) {
auto& name = pair.first;
for (Int i = 0; i < indent; ++i) {
stream << " ";
}
stream << name << ":";
echo_input_recursive(stream, *(pair.second), indent + 1);
}
} else if (is_type<InputList>(input)) {
auto& list = as_type<InputList>(input);
stream << '\n';
for (LO i = 0; i < list.size(); ++i) {
for (Int j = 0; j < indent; ++j) {
stream << " ";
}
stream << "-";
echo_input_recursive(stream, *(list.entries[std::size_t(i)]), indent + 1);
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d0f40
testb $0x1, %al
jne 0x39df78
jmp 0x39e0bf
movq -0x10(%rbp), %rdi
callq 0x1bfd20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x1cab90
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x1c3fe0
movq %rax, -0x38(%rbp)
movb $0xa, -0x39(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x39(%rbp), %rdx
callq 0x1c2b80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x1c3fe0
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1daa60
testb $0x1, %al
jne 0x39dfe7
jmp 0x39e08d
movq -0x8(%rbp), %rdi
leaq 0x294872(%rip), %rsi # 0x632864
callq 0x1cd8f0
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1cab90
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1c3fe0
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1daa60
testb $0x1, %al
jne 0x39e030
jmp 0x39e08b
leaq -0x58(%rbp), %rdi
callq 0x1ce7e0
movb (%rax), %al
movb %al, -0x61(%rbp)
movsbl -0x61(%rbp), %eax
cmpl $0xa, %eax
jne 0x39e073
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x39e071
movq -0x8(%rbp), %rdi
leaq 0x28f787(%rip), %rsi # 0x62d7e8
callq 0x1cd8f0
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x39e04e
jmp 0x39e073
movq -0x8(%rbp), %rdi
movsbl -0x61(%rbp), %esi
callq 0x1d19c0
leaq -0x58(%rbp), %rdi
callq 0x1cd7b0
jmp 0x39e01d
jmp 0x39e0ba
movq -0x8(%rbp), %rdi
leaq 0x294c5d(%rip), %rsi # 0x632cf5
callq 0x1cd8f0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
callq 0x1cb420
movq %rax, %rdi
movl $0x27, %esi
callq 0x1d19c0
jmp 0x39e2e5
movq -0x10(%rbp), %rdi
callq 0x1cc0f0
testb $0x1, %al
jne 0x39e0d1
jmp 0x39e1e4
movq -0x10(%rbp), %rdi
callq 0x1ddaa0
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x1d19c0
movq -0x70(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x1b9c30
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x1c5050
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1d94b0
testb $0x1, %al
jne 0x39e12e
jmp 0x39e1df
leaq -0x80(%rbp), %rdi
callq 0x1bb1a0
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x39e182
movq -0x8(%rbp), %rdi
leaq 0x28f67c(%rip), %rsi # 0x62d7e8
callq 0x1cd8f0
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x39e156
movq -0x8(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x1cb420
movq %rax, %rdi
leaq 0x28d0d9(%rip), %rsi # 0x62b275
callq 0x1cd8f0
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x90(%rbp), %rdi
addq $0x20, %rdi
callq 0x1d9040
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x39df50
leaq -0x80(%rbp), %rdi
callq 0x1cf8a0
jmp 0x39e115
jmp 0x39e2e3
movq -0x10(%rbp), %rdi
callq 0x1dc7e0
testb $0x1, %al
jne 0x39e1f6
jmp 0x39e2e1
movq -0x10(%rbp), %rdi
callq 0x1c0c60
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x1d19c0
movl $0x0, -0xac(%rbp)
movl -0xac(%rbp), %eax
movl %eax, -0xbc(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x1bc3c0
movl %eax, %ecx
movl -0xbc(%rbp), %eax
cmpl %ecx, %eax
jge 0x39e2df
movl $0x0, -0xb0(%rbp)
movl -0xb0(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x39e27c
movq -0x8(%rbp), %rdi
leaq 0x28f582(%rip), %rsi # 0x62d7e8
callq 0x1cd8f0
movl -0xb0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb0(%rbp)
jmp 0x39e250
movq -0x8(%rbp), %rdi
leaq 0x297177(%rip), %rsi # 0x6353fe
callq 0x1cd8f0
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xa8(%rbp), %rdi
addq $0x18, %rdi
movslq -0xac(%rbp), %rsi
callq 0x1d2a40
movq %rax, %rdi
callq 0x1d9040
movq -0xc8(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x39df50
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x39e21e
jmp 0x39e2e1
jmp 0x39e2e3
jmp 0x39e2e5
addq $0xd0, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,045 | Omega_h::check_unused(Omega_h::Input&) | void check_unused(Input& input) {
if (!input.used) {
auto const full_name = get_full_name(input);
Omega_h_fail("input \"%s\" was not used!\n", full_name.c_str());
}
if (is_type<InputMap>(input)) {
auto& map = as_type<InputMap>(input);
for (auto& pair : map.map) {
check_unused(*(pair.second));
}
} else if (is_type<InputList>(input)) {
auto& list = as_type<InputList>(input);
for (LO i = 0; i < list.size(); ++i) {
check_unused(*(list.entries[std::size_t(i)]));
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x39e350
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1d08e0
movq -0x78(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rsi
leaq 0x2944f6(%rip), %rdi # 0x632823
xorl %eax, %eax
callq 0x1ce550
jmp 0x39e336
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1c4d10
jmp 0x39e448
movq -0x8(%rbp), %rdi
callq 0x1cc0f0
testb $0x1, %al
jne 0x39e35f
jmp 0x39e3d4
movq -0x8(%rbp), %rdi
callq 0x1ddaa0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1b9c30
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1c5050
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1d94b0
testb $0x1, %al
jne 0x39e3a5
jmp 0x39e3d2
leaq -0x50(%rbp), %rdi
callq 0x1bb1a0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1e0c40
leaq -0x50(%rbp), %rdi
callq 0x1cf8a0
jmp 0x39e392
jmp 0x39e43f
movq -0x8(%rbp), %rdi
callq 0x1dc7e0
testb $0x1, %al
jne 0x39e3e3
jmp 0x39e43d
movq -0x8(%rbp), %rdi
callq 0x1c0c60
movq %rax, -0x68(%rbp)
movl $0x0, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x7c(%rbp)
movq -0x68(%rbp), %rdi
callq 0x1bc3c0
movl %eax, %ecx
movl -0x7c(%rbp), %eax
cmpl %ecx, %eax
jge 0x39e43b
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movslq -0x6c(%rbp), %rsi
callq 0x1d2a40
movq %rax, %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1e0c40
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x39e3f7
jmp 0x39e43d
jmp 0x39e43f
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,046 | Omega_h::handle_one_include(Omega_h::InputList&) | static bool handle_one_include(InputList& list) {
for (LO i = 0; i < list.size(); ++i) {
if (list.is_list(i)) {
if (handle_one_include(list.get_list(i))) return true;
} else if (list.is_map(i)) {
if (handle_one_include(list.get_map(i))) return true;
}
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc3c0
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jge 0x39e505
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1c6ed0
testb $0x1, %al
jne 0x39e49d
jmp 0x39e4bf
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bde10
movq %rax, %rdi
callq 0x39e460
testb $0x1, %al
jne 0x39e4b7
jmp 0x39e4bd
movb $0x1, -0x1(%rbp)
jmp 0x39e509
jmp 0x39e4f5
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1d0d20
testb $0x1, %al
jne 0x39e4d1
jmp 0x39e4f3
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bc230
movq %rax, %rdi
callq 0x39db50
testb $0x1, %al
jne 0x39e4eb
jmp 0x39e4f1
movb $0x1, -0x1(%rbp)
jmp 0x39e509
jmp 0x39e4f3
jmp 0x39e4f5
jmp 0x39e4f7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x39e473
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,047 | Omega_h::remove_trailing_whitespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::string remove_trailing_whitespace(std::string const& in) {
std::size_t new_end = 0;
for (std::size_t ri = 0; ri < in.size(); ++ri) {
std::size_t i = in.size() - 1 - ri;
if (in[i] != ' ' && in[i] != '\t') {
new_end = i + 1;
break;
}
}
return in.substr(0, new_end);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c6990
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x39e5c5
movq -0x10(%rbp), %rdi
callq 0x1c6990
subq $0x1, %rax
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1cfb90
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x39e5b5
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1cfb90
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x39e5b5
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x39e5c5
jmp 0x39e5b7
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x39e54b
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x1ce800
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,048 | Omega_h::my_isdigit(char) | static bool my_isdigit(char ch) {
return std::isdigit(static_cast<unsigned char>(ch));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %edi
callq 0x1cb440
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,049 | Omega_h::remove_trailing_whitespace_and_newlines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::string remove_trailing_whitespace_and_newlines(
std::string const& in) {
std::size_t new_end = 0;
for (std::size_t ri = 0; ri < in.size(); ++ri) {
std::size_t i = in.size() - 1 - ri;
if (in[i] != ' ' && in[i] != '\t' && in[i] != '\n' && in[i] != '\r') {
new_end = i + 1;
break;
}
}
return in.substr(0, new_end);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c6990
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x39e6f6
movq -0x10(%rbp), %rdi
callq 0x1c6990
subq $0x1, %rax
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1cfb90
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x39e6e3
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1cfb90
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x39e6e3
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1cfb90
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x39e6e3
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1cfb90
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0x39e6e3
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x39e6f6
jmp 0x39e6e5
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x39e64b
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x1ce800
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,050 | _gnu_cxx::__ops::_Iter_pred<Omega_h::InputList::position(Omega_h::Input const&)::$_0>::_Iter_pred(Omega_h::InputList::position(Omega_h::Input const&)::$_0) | _Iter_pred(_Predicate __pred)
: _M_pred(_GLIBCXX_MOVE(__pred))
{ } | pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/predefined_ops.h |
6,051 | bool Omega_h::is_type<Omega_h::InputScalar>(Omega_h::Input&) | bool is_type(Input& input) {
auto ptr_in = &input;
auto ptr_out = dynamic_cast<InputType*>(ptr_in);
return ptr_out != nullptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x39ea73
movq -0x20(%rbp), %rdi
movq 0x35902b(%rip), %rsi # 0x6f7a88
movq 0x35908c(%rip), %rdx # 0x6f7af0
xorl %eax, %eax
movl %eax, %ecx
callq 0x1d0af0
movq %rax, -0x28(%rbp)
jmp 0x39ea7b
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x39ea7b
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,052 | Omega_h::InputScalar& Omega_h::as_type<Omega_h::InputScalar>(Omega_h::Input&) | InputType& as_type(Input& input) {
return dynamic_cast<InputType&>(input);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x358fd1(%rip), %rsi # 0x6f7a88
movq 0x359032(%rip), %rdx # 0x6f7af0
xorl %eax, %eax
movl %eax, %ecx
callq 0x1d0af0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x39ead6
callq 0x1e2b40
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,053 | bool Omega_h::InputMap::is_input<Omega_h::InputScalar>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool InputMap::is_input(std::string const& name) {
auto const it = map.find(name);
if (it == map.end()) return false;
auto const& sptr = it->second;
return is_type<InputType>(*sptr);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x1bef10
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x1c5050
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c5950
testb $0x1, %al
jne 0x39eb2d
jmp 0x39eb33
movb $0x0, -0x1(%rbp)
jmp 0x39eb5a
leaq -0x20(%rbp), %rdi
callq 0x1df480
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1d0f40
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,054 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<Omega_h::Input>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<Omega_h::Input>>>>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | iterator
find(const key_type& __x)
{ return _M_t.find(__x); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1bef40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
6,055 | std::operator==(std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<Omega_h::Input>>> const&, std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<Omega_h::Input>>> const&) | bool
operator==(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT
{ return __x._M_node == __y._M_node; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
6,056 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<Omega_h::Input>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<Omega_h::Input>>>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return _M_t.end(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d5d90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
6,057 | std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<Omega_h::Input>>>::operator->() const | pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return static_cast<_Link_type> (_M_node)->_M_valptr(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1e0370
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
6,058 | std::__shared_ptr_access<Omega_h::Input, (__gnu_cxx::_Lock_policy)2, false, false>::operator*() const | element_type&
operator*() const noexcept
{
__glibcxx_assert(_M_get() != nullptr);
return *_M_get();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x39ec36
jmp 0x39ec38
movq -0x10(%rbp), %rdi
callq 0x1bd1d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
6,059 | Omega_h::InputScalar& Omega_h::InputMap::use_input<Omega_h::InputScalar>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | InputType& InputMap::use_input(std::string const& name) {
return Omega_h::use_input<InputType>(find_named_input(name));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b90a0
movq %rax, %rdi
callq 0x39c210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,060 | bool Omega_h::InputList::is_input<Omega_h::InputScalar>(int) | bool InputList::is_input(LO i) {
return Omega_h::is_type<InputType>(this->at(i));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c3c40
movq %rax, %rdi
callq 0x1d0f40
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,061 | Omega_h::InputScalar& Omega_h::InputList::use_input<Omega_h::InputScalar>(int) | InputType& InputList::use_input(LO i) {
return Omega_h::use_input<InputType>(this->at(i));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c3c40
movq %rax, %rdi
callq 0x39c210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,062 | bool Omega_h::is_type<Omega_h::InputMap>(Omega_h::Input&) | bool is_type(Input& input) {
auto ptr_in = &input;
auto ptr_out = dynamic_cast<InputType*>(ptr_in);
return ptr_out != nullptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x39ed23
movq -0x20(%rbp), %rdi
movq 0x358d7b(%rip), %rsi # 0x6f7a88
movq 0x358f84(%rip), %rdx # 0x6f7c98
xorl %eax, %eax
movl %eax, %ecx
callq 0x1d0af0
movq %rax, -0x28(%rbp)
jmp 0x39ed2b
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x39ed2b
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,063 | Omega_h::InputMap& Omega_h::as_type<Omega_h::InputMap>(Omega_h::Input&) | InputType& as_type(Input& input) {
return dynamic_cast<InputType&>(input);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x358d21(%rip), %rsi # 0x6f7a88
movq 0x358f2a(%rip), %rdx # 0x6f7c98
xorl %eax, %eax
movl %eax, %ecx
callq 0x1d0af0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x39ed86
callq 0x1e2b40
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,064 | bool Omega_h::InputMap::is_input<Omega_h::InputMap>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool InputMap::is_input(std::string const& name) {
auto const it = map.find(name);
if (it == map.end()) return false;
auto const& sptr = it->second;
return is_type<InputType>(*sptr);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x1bef10
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x1c5050
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c5950
testb $0x1, %al
jne 0x39eddd
jmp 0x39ede3
movb $0x0, -0x1(%rbp)
jmp 0x39ee0a
leaq -0x20(%rbp), %rdi
callq 0x1df480
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1cc0f0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,065 | Omega_h::InputMap& Omega_h::InputMap::use_input<Omega_h::InputMap>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | InputType& InputMap::use_input(std::string const& name) {
return Omega_h::use_input<InputType>(find_named_input(name));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b90a0
movq %rax, %rdi
callq 0x39c3c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,066 | bool Omega_h::InputList::is_input<Omega_h::InputMap>(int) | bool InputList::is_input(LO i) {
return Omega_h::is_type<InputType>(this->at(i));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c3c40
movq %rax, %rdi
callq 0x1cc0f0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,067 | Omega_h::InputMap& Omega_h::InputList::use_input<Omega_h::InputMap>(int) | InputType& InputList::use_input(LO i) {
return Omega_h::use_input<InputType>(this->at(i));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c3c40
movq %rax, %rdi
callq 0x39c3c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,068 | bool Omega_h::is_type<Omega_h::InputList>(Omega_h::Input&) | bool is_type(Input& input) {
auto ptr_in = &input;
auto ptr_out = dynamic_cast<InputType*>(ptr_in);
return ptr_out != nullptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x39eef3
movq -0x20(%rbp), %rdi
movq 0x358bab(%rip), %rsi # 0x6f7a88
movq 0x358c9c(%rip), %rdx # 0x6f7b80
xorl %eax, %eax
movl %eax, %ecx
callq 0x1d0af0
movq %rax, -0x28(%rbp)
jmp 0x39eefb
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x39eefb
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,069 | Omega_h::InputList& Omega_h::as_type<Omega_h::InputList>(Omega_h::Input&) | InputType& as_type(Input& input) {
return dynamic_cast<InputType&>(input);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x358b51(%rip), %rsi # 0x6f7a88
movq 0x358c42(%rip), %rdx # 0x6f7b80
xorl %eax, %eax
movl %eax, %ecx
callq 0x1d0af0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x39ef56
callq 0x1e2b40
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,070 | bool Omega_h::InputMap::is_input<Omega_h::InputList>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool InputMap::is_input(std::string const& name) {
auto const it = map.find(name);
if (it == map.end()) return false;
auto const& sptr = it->second;
return is_type<InputType>(*sptr);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x1bef10
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x1c5050
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c5950
testb $0x1, %al
jne 0x39efad
jmp 0x39efb3
movb $0x0, -0x1(%rbp)
jmp 0x39efda
leaq -0x20(%rbp), %rdi
callq 0x1df480
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1dc7e0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,071 | Omega_h::InputList& Omega_h::InputMap::use_input<Omega_h::InputList>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | InputType& InputMap::use_input(std::string const& name) {
return Omega_h::use_input<InputType>(find_named_input(name));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b90a0
movq %rax, %rdi
callq 0x39c3f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,072 | bool Omega_h::InputList::is_input<Omega_h::InputList>(int) | bool InputList::is_input(LO i) {
return Omega_h::is_type<InputType>(this->at(i));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c3c40
movq %rax, %rdi
callq 0x1dc7e0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,073 | Omega_h::InputList& Omega_h::InputList::use_input<Omega_h::InputList>(int) | InputType& InputList::use_input(LO i) {
return Omega_h::use_input<InputType>(this->at(i));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c3c40
movq %rax, %rdi
callq 0x39c3f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,074 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Omega_h::InputScalar::get<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>() const | T InputScalar::get() const {
T out;
if (!as(out)) {
auto full_name = get_full_name(*this);
Omega_h_fail(
"InputScalar \"%s\" string \"%s\" is not interpretable as a %s",
full_name.c_str(), str.c_str(),
(std::is_same<T, int>::value
? "int"
: (std::is_same<T, double>::value
? "double"
: (std::is_same<T, long long>::value
? "long long"
: "unknown type"))));
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1d67d0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x1c5820
movb %al, -0x49(%rbp)
jmp 0x39f0be
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x39f133
jmp 0x39f0c7
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1d08e0
jmp 0x39f0d6
leaq -0x48(%rbp), %rdi
callq 0x1bf7a0
movq -0x60(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x18, %rdi
callq 0x1bf7a0
movq -0x70(%rbp), %rsi
movq %rax, %rdx
leaq 0x293541(%rip), %rdi # 0x63263f
leaq 0x293574(%rip), %rcx # 0x632679
xorl %eax, %eax
callq 0x1ce550
jmp 0x39f10e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x39f150
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1c4d10
jmp 0x39f150
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x39f146
movq -0x58(%rbp), %rdi
callq 0x1c4d10
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x1c4d10
movq -0x20(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,075 | bool Omega_h::InputMap::is<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool InputMap::is(std::string const& name) {
auto const it = map.find(name);
if (it == map.end()) return false;
auto const& sptr = it->second;
ScalarType ignored;
return is_type<InputScalar>(*sptr) && as_type<InputScalar>(*sptr).as(ignored);
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x1bef10
movq -0x68(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x1c5050
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c5950
testb $0x1, %al
jne 0x39f1c0
jmp 0x39f1c9
movb $0x0, -0x1(%rbp)
jmp 0x39f25d
leaq -0x20(%rbp), %rdi
callq 0x1df480
addq $0x20, %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1d67d0
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1d0f40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x69(%rbp)
jne 0x39f202
jmp 0x39f233
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1bfd20
movq %rax, -0x78(%rbp)
jmp 0x39f219
movq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1c5820
movb %al, -0x79(%rbp)
jmp 0x39f22b
movb -0x79(%rbp), %al
movb %al, -0x69(%rbp)
jmp 0x39f233
movb -0x69(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
jmp 0x39f25d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
jmp 0x39f26b
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,076 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Omega_h::InputMap::get<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ScalarType InputMap::get(std::string const& name) {
return this->use_input<InputScalar>(name).get<ScalarType>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d3860
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1ba270
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,077 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Omega_h::InputMap::get<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | ScalarType InputMap::get(std::string const& name, char const* default_value) {
if (!this->is<ScalarType>(name)) set(name, default_value);
return this->get<ScalarType>(name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1c7d10
testb $0x1, %al
jne 0x39f319
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1ba8f0
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rdx
callq 0x1c78c0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,078 | bool Omega_h::InputList::is<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(int) | bool InputList::is(LO i) {
Input& input = at(i);
ScalarType ignored;
return is_type<InputScalar>(input) && as_type<InputScalar>(input).as(ignored);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c3c40
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1d67d0
movq -0x18(%rbp), %rdi
callq 0x1d0f40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x45(%rbp)
jne 0x39f37f
jmp 0x39f3a8
movq -0x18(%rbp), %rdi
callq 0x1bfd20
movq %rax, -0x50(%rbp)
jmp 0x39f38e
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1c5820
movb %al, -0x51(%rbp)
jmp 0x39f3a0
movb -0x51(%rbp), %al
movb %al, -0x45(%rbp)
jmp 0x39f3a8
movb -0x45(%rbp), %al
movb %al, -0x52(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
movb -0x52(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
movq -0x40(%rbp), %rdi
callq 0x1dfa40
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,079 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Omega_h::InputList::get<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(int) | ScalarType InputList::get(LO i) {
return this->use_input<InputScalar>(i).get<ScalarType>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1dc210
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1ba270
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,080 | bool Omega_h::InputScalar::get<bool>() const | T InputScalar::get() const {
T out;
if (!as(out)) {
auto full_name = get_full_name(*this);
Omega_h_fail(
"InputScalar \"%s\" string \"%s\" is not interpretable as a %s",
full_name.c_str(), str.c_str(),
(std::is_same<T, int>::value
? "int"
: (std::is_same<T, double>::value
? "double"
: (std::is_same<T, long long>::value
? "long long"
: "unknown type"))));
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x9(%rbp), %rsi
callq 0x1c9f50
testb $0x1, %al
jne 0x39f4a1
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1d08e0
movq -0x58(%rbp), %rdi
callq 0x1bf7a0
movq -0x48(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x18, %rdi
callq 0x1bf7a0
movq -0x50(%rbp), %rsi
movq %rax, %rdx
leaq 0x2931c5(%rip), %rdi # 0x63263f
leaq 0x2931f8(%rip), %rcx # 0x632679
xorl %eax, %eax
callq 0x1ce550
jmp 0x39f48a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c4d10
jmp 0x39f4ac
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,081 | bool Omega_h::InputMap::is<bool>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool InputMap::is(std::string const& name) {
auto const it = map.find(name);
if (it == map.end()) return false;
auto const& sptr = it->second;
ScalarType ignored;
return is_type<InputScalar>(*sptr) && as_type<InputScalar>(*sptr).as(ignored);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x1bef10
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x1c5050
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c5950
testb $0x1, %al
jne 0x39f50d
jmp 0x39f513
movb $0x0, -0x1(%rbp)
jmp 0x39f56b
leaq -0x20(%rbp), %rdi
callq 0x1df480
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1d0f40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x39f543
jmp 0x39f563
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1bfd20
movq %rax, %rdi
leaq -0x31(%rbp), %rsi
callq 0x1c9f50
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,082 | bool Omega_h::InputMap::get<bool>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ScalarType InputMap::get(std::string const& name) {
return this->use_input<InputScalar>(name).get<ScalarType>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d3860
movq %rax, %rdi
callq 0x1da4f0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,083 | bool Omega_h::InputMap::get<bool>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | ScalarType InputMap::get(std::string const& name, char const* default_value) {
if (!this->is<ScalarType>(name)) set(name, default_value);
return this->get<ScalarType>(name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d1c40
testb $0x1, %al
jne 0x39f5ea
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1ba8f0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b9610
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,084 | bool Omega_h::InputList::is<bool>(int) | bool InputList::is(LO i) {
Input& input = at(i);
ScalarType ignored;
return is_type<InputScalar>(input) && as_type<InputScalar>(input).as(ignored);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c3c40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d0f40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x39f636
jmp 0x39f64e
movq -0x18(%rbp), %rdi
callq 0x1bfd20
movq %rax, %rdi
leaq -0x19(%rbp), %rsi
callq 0x1c9f50
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,085 | bool Omega_h::InputList::get<bool>(int) | ScalarType InputList::get(LO i) {
return this->use_input<InputScalar>(i).get<ScalarType>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1dc210
movq %rax, %rdi
callq 0x1da4f0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,086 | double Omega_h::InputScalar::get<double>() const | T InputScalar::get() const {
T out;
if (!as(out)) {
auto full_name = get_full_name(*this);
Omega_h_fail(
"InputScalar \"%s\" string \"%s\" is not interpretable as a %s",
full_name.c_str(), str.c_str(),
(std::is_same<T, int>::value
? "int"
: (std::is_same<T, double>::value
? "double"
: (std::is_same<T, long long>::value
? "long long"
: "unknown type"))));
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x1d5210
testb $0x1, %al
jne 0x39f711
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1d08e0
movq -0x58(%rbp), %rdi
callq 0x1bf7a0
movq -0x48(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x18, %rdi
callq 0x1bf7a0
movq -0x50(%rbp), %rsi
movq %rax, %rdx
leaq 0x292f55(%rip), %rdi # 0x63263f
leaq 0x28e81f(%rip), %rcx # 0x62df10
xorl %eax, %eax
callq 0x1ce550
jmp 0x39f6fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c4d10
jmp 0x39f71c
movsd -0x10(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,087 | bool Omega_h::InputMap::is<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool InputMap::is(std::string const& name) {
auto const it = map.find(name);
if (it == map.end()) return false;
auto const& sptr = it->second;
ScalarType ignored;
return is_type<InputScalar>(*sptr) && as_type<InputScalar>(*sptr).as(ignored);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x1bef10
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x1c5050
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c5950
testb $0x1, %al
jne 0x39f77d
jmp 0x39f783
movb $0x0, -0x1(%rbp)
jmp 0x39f7db
leaq -0x20(%rbp), %rdi
callq 0x1df480
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1d0f40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x39f7b3
jmp 0x39f7d3
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1bfd20
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0x1d5210
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,088 | double Omega_h::InputMap::get<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ScalarType InputMap::get(std::string const& name) {
return this->use_input<InputScalar>(name).get<ScalarType>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d3860
movq %rax, %rdi
callq 0x1d9ef0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,089 | double Omega_h::InputMap::get<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | ScalarType InputMap::get(std::string const& name, char const* default_value) {
if (!this->is<ScalarType>(name)) set(name, default_value);
return this->get<ScalarType>(name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c95c0
testb $0x1, %al
jne 0x39f85a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1ba8f0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1dd270
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,090 | bool Omega_h::InputList::is<double>(int) | bool InputList::is(LO i) {
Input& input = at(i);
ScalarType ignored;
return is_type<InputScalar>(input) && as_type<InputScalar>(input).as(ignored);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c3c40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d0f40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x39f8a6
jmp 0x39f8be
movq -0x18(%rbp), %rdi
callq 0x1bfd20
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x1d5210
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,091 | double Omega_h::InputList::get<double>(int) | ScalarType InputList::get(LO i) {
return this->use_input<InputScalar>(i).get<ScalarType>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1dc210
movq %rax, %rdi
callq 0x1d9ef0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,092 | int Omega_h::InputScalar::get<int>() const | T InputScalar::get() const {
T out;
if (!as(out)) {
auto full_name = get_full_name(*this);
Omega_h_fail(
"InputScalar \"%s\" string \"%s\" is not interpretable as a %s",
full_name.c_str(), str.c_str(),
(std::is_same<T, int>::value
? "int"
: (std::is_same<T, double>::value
? "double"
: (std::is_same<T, long long>::value
? "long long"
: "unknown type"))));
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x1c4c00
testb $0x1, %al
jne 0x39f981
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1d08e0
movq -0x58(%rbp), %rdi
callq 0x1bf7a0
movq -0x48(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x18, %rdi
callq 0x1bf7a0
movq -0x50(%rbp), %rsi
movq %rax, %rdx
leaq 0x292ce5(%rip), %rdi # 0x63263f
leaq 0x28e5ab(%rip), %rcx # 0x62df0c
xorl %eax, %eax
callq 0x1ce550
jmp 0x39f96a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c4d10
jmp 0x39f98a
movl -0xc(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,093 | bool Omega_h::InputMap::is<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool InputMap::is(std::string const& name) {
auto const it = map.find(name);
if (it == map.end()) return false;
auto const& sptr = it->second;
ScalarType ignored;
return is_type<InputScalar>(*sptr) && as_type<InputScalar>(*sptr).as(ignored);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x1bef10
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x1c5050
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c5950
testb $0x1, %al
jne 0x39f9ed
jmp 0x39f9f3
movb $0x0, -0x1(%rbp)
jmp 0x39fa4b
leaq -0x20(%rbp), %rdi
callq 0x1df480
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1d0f40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x39fa23
jmp 0x39fa43
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1bfd20
movq %rax, %rdi
leaq -0x34(%rbp), %rsi
callq 0x1c4c00
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,094 | int Omega_h::InputMap::get<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ScalarType InputMap::get(std::string const& name) {
return this->use_input<InputScalar>(name).get<ScalarType>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d3860
movq %rax, %rdi
callq 0x1cceb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,095 | int Omega_h::InputMap::get<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | ScalarType InputMap::get(std::string const& name, char const* default_value) {
if (!this->is<ScalarType>(name)) set(name, default_value);
return this->get<ScalarType>(name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1e2360
testb $0x1, %al
jne 0x39faca
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1ba8f0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1de2f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,096 | bool Omega_h::InputList::is<int>(int) | bool InputList::is(LO i) {
Input& input = at(i);
ScalarType ignored;
return is_type<InputScalar>(input) && as_type<InputScalar>(input).as(ignored);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c3c40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d0f40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1d(%rbp)
jne 0x39fb16
jmp 0x39fb2e
movq -0x18(%rbp), %rdi
callq 0x1bfd20
movq %rax, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1c4c00
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,097 | int Omega_h::InputList::get<int>(int) | ScalarType InputList::get(LO i) {
return this->use_input<InputScalar>(i).get<ScalarType>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1dc210
movq %rax, %rdi
callq 0x1cceb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,098 | long long Omega_h::InputScalar::get<long long>() const | T InputScalar::get() const {
T out;
if (!as(out)) {
auto full_name = get_full_name(*this);
Omega_h_fail(
"InputScalar \"%s\" string \"%s\" is not interpretable as a %s",
full_name.c_str(), str.c_str(),
(std::is_same<T, int>::value
? "int"
: (std::is_same<T, double>::value
? "double"
: (std::is_same<T, long long>::value
? "long long"
: "unknown type"))));
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x1bef00
testb $0x1, %al
jne 0x39fbf1
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1d08e0
movq -0x58(%rbp), %rdi
callq 0x1bf7a0
movq -0x48(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x18, %rdi
callq 0x1bf7a0
movq -0x50(%rbp), %rsi
movq %rax, %rdx
leaq 0x292a75(%rip), %rdi # 0x63263f
leaq 0x292ab5(%rip), %rcx # 0x632686
xorl %eax, %eax
callq 0x1ce550
jmp 0x39fbda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c4d10
jmp 0x39fbfb
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
6,099 | bool Omega_h::InputMap::is<long long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool InputMap::is(std::string const& name) {
auto const it = map.find(name);
if (it == map.end()) return false;
auto const& sptr = it->second;
ScalarType ignored;
return is_type<InputScalar>(*sptr) && as_type<InputScalar>(*sptr).as(ignored);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x1bef10
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x1c5050
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c5950
testb $0x1, %al
jne 0x39fc5d
jmp 0x39fc63
movb $0x0, -0x1(%rbp)
jmp 0x39fcbb
leaq -0x20(%rbp), %rdi
callq 0x1df480
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1d0f40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x39fc93
jmp 0x39fcb3
movq -0x30(%rbp), %rdi
callq 0x1d9040
movq %rax, %rdi
callq 0x1bfd20
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0x1bef00
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_input.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.