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
|
|---|---|---|---|---|---|---|
5,000 | Omega_h::filesystem::directory_iterator::operator==(Omega_h::filesystem::directory_iterator const&) const | bool directory_iterator::operator==(directory_iterator const& other) const {
return impl->equal(*other.impl);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1d5450
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_filesystem.cpp |
5,001 | Omega_h::filesystem::directory_iterator::operator->() const | const directory_entry* directory_iterator::operator->() const { return &entry; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
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_filesystem.cpp |
5,002 | Omega_h::filesystem::directory_entry::is_directory() const | bool directory_entry::is_directory() const {
return status(path_variable).type() == file_type::directory;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e43d0
movl %eax, -0xc(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1dafe0
cmpl $0x3, %eax
sete %al
andb $0x1, %al
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_filesystem.cpp |
5,003 | Omega_h::filesystem::filesystem_error::~filesystem_error() | filesystem_error::~filesystem_error() {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ca9e0
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_filesystem.cpp |
5,004 | Omega_h::filesystem::filesystem_error::~filesystem_error() | filesystem_error::~filesystem_error() {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1e4e88
movq -0x10(%rbp), %rdi
movl $0x20, %esi
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_filesystem.cpp |
5,005 | Omega_h::filesystem::path::path(char const*) | path::path(char const* source) : impl(source) {} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1dfbb0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1d5e00
jmp 0x35b640
leaq -0x11(%rbp), %rdi
callq 0x1cf450
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x1cf450
movq -0x20(%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_filesystem.cpp |
5,006 | Omega_h::filesystem::path::path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | path::path(std::string const& source) : impl(source) {} | 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 0x1c00c0
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_filesystem.cpp |
5,007 | Omega_h::filesystem::path::native[abi:cxx11]() const | const path::string_type& path::native() const noexcept { return impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_filesystem.cpp |
5,008 | Omega_h::filesystem::path::string[abi:cxx11]() const | std::string path::string() const { return impl; } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c00c0
movq -0x18(%rbp), %rax
addq $0x20, %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_filesystem.cpp |
5,009 | Omega_h::filesystem::path::filename() const | path path::filename() const {
auto const last_sep_pos = impl.find_last_of(preferred_separator);
if (last_sep_pos == std::string::npos) return impl;
return impl.substr(last_sep_pos + 1, std::string::npos);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x1e33b0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x35b72e
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x1dc480
jmp 0x35b77e
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdx
incq %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq $-0x1, %rcx
callq 0x1ce800
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x1dc480
jmp 0x35b75c
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
jmp 0x35b77e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
jmp 0x35b788
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%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_filesystem.cpp |
5,010 | Omega_h::filesystem::path::parent_path() const | path path::parent_path() const {
auto const last_sep_pos = impl.find_last_of(preferred_separator);
if (last_sep_pos == std::string::npos) return impl;
return impl.substr(0, last_sep_pos);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x1e33b0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x35b7ee
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x1dc480
jmp 0x35b838
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1ce800
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x1dc480
jmp 0x35b816
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
jmp 0x35b838
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
jmp 0x35b842
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1dfa40
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_filesystem.cpp |
5,011 | Omega_h::filesystem::path::extension() const | path path::extension() const {
auto const filename_str = filename().native();
auto const last_dot_pos = filename_str.find_last_of('.');
// If the pathname is either . or .., or if filename() does not contain the .
// character, then empty path is returned.
if (last_dot_pos == std::string::npos) return path();
if (filename_str == "." || filename_str == "..") return path();
// If the first character in the filename is a period, that period is ignored
// (a filename like ".profile" is not treated as an extension)
if (last_dot_pos == 0) return path();
// If the filename() component of the generic-format path contains a period
// (.), and is not one of the special filesystem elements dot or dot-dot, then
// the extension is the substring beginning at the rightmost period (including
// the period) and until the end of the pathname.
return filename_str.substr(last_dot_pos, std::string::npos);
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1d57e0
movq -0x98(%rbp), %rdi
callq 0x1c25a0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x1c00c0
jmp 0x35b8a2
leaq -0x50(%rbp), %rdi
callq 0x1b9420
leaq -0x30(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x1e33b0
movq %rax, -0x68(%rbp)
cmpq $-0x1, -0x68(%rbp)
jne 0x35b910
movq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1c2d80
movq -0xa8(%rbp), %rdi
callq 0x1c26b0
movl $0x1, -0x6c(%rbp)
jmp 0x35ba24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1b9420
jmp 0x35ba46
leaq 0x2d16ab(%rip), %rsi # 0x62cfc2
leaq -0x30(%rbp), %rdi
callq 0x1e4c20
movb %al, -0xa9(%rbp)
jmp 0x35b928
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x35b958
jmp 0x35b934
leaq 0x2d5466(%rip), %rsi # 0x630da1
leaq -0x30(%rbp), %rdi
callq 0x1e4c20
movb %al, -0xaa(%rbp)
jmp 0x35b94c
movb -0xaa(%rbp), %al
testb $0x1, %al
jne 0x35b958
jmp 0x35b994
movq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1c2d80
movq -0xa8(%rbp), %rdi
callq 0x1c26b0
movl $0x1, -0x6c(%rbp)
jmp 0x35ba24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x35ba3d
cmpq $0x0, -0x68(%rbp)
jne 0x35b9c3
movq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1c2d80
movq -0xa8(%rbp), %rdi
callq 0x1c26b0
movl $0x1, -0x6c(%rbp)
jmp 0x35ba24
movq -0x68(%rbp), %rdx
leaq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq $-0x1, %rcx
callq 0x1ce800
jmp 0x35b9e0
movq -0xa8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1dc480
jmp 0x35b9f5
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
movl $0x1, -0x6c(%rbp)
jmp 0x35ba24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
jmp 0x35ba3d
leaq -0x30(%rbp), %rdi
callq 0x1c4d10
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x1c4d10
movq -0x58(%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_filesystem.cpp |
5,012 | Omega_h::filesystem::path::stem() const | path path::stem() const {
auto const filename_str = filename().native();
auto const last_dot_pos = filename_str.find_last_of('.');
if (last_dot_pos == std::string::npos) return filename_str;
if (filename_str == "." || filename_str == "..") return filename_str;
if (last_dot_pos == 0) return filename_str;
return filename_str.substr(0, last_dot_pos);
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1d57e0
movq -0x98(%rbp), %rdi
callq 0x1c25a0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x1c00c0
jmp 0x35baa2
leaq -0x50(%rbp), %rdi
callq 0x1b9420
leaq -0x30(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x1e33b0
movq %rax, -0x68(%rbp)
cmpq $-0x1, -0x68(%rbp)
jne 0x35bb14
movq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1dc480
jmp 0x35badd
movl $0x1, -0x6c(%rbp)
jmp 0x35bbfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1b9420
jmp 0x35bc1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x35bc13
leaq 0x2d14a7(%rip), %rsi # 0x62cfc2
leaq -0x30(%rbp), %rdi
callq 0x1e4c20
movb %al, -0xa9(%rbp)
jmp 0x35bb2c
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x35bb5c
jmp 0x35bb38
leaq 0x2d5262(%rip), %rsi # 0x630da1
leaq -0x30(%rbp), %rdi
callq 0x1e4c20
movb %al, -0xaa(%rbp)
jmp 0x35bb50
movb -0xaa(%rbp), %al
testb $0x1, %al
jne 0x35bb5c
jmp 0x35bb7a
movq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1dc480
jmp 0x35bb6e
movl $0x1, -0x6c(%rbp)
jmp 0x35bbfa
cmpq $0x0, -0x68(%rbp)
jne 0x35bb9c
movq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1dc480
jmp 0x35bb93
movl $0x1, -0x6c(%rbp)
jmp 0x35bbfa
movq -0x68(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1ce800
jmp 0x35bbb6
movq -0xa8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1dc480
jmp 0x35bbcb
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
movl $0x1, -0x6c(%rbp)
jmp 0x35bbfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
jmp 0x35bc13
leaq -0x30(%rbp), %rdi
callq 0x1c4d10
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x1c4d10
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_filesystem.cpp |
5,013 | Omega_h::filesystem::path::operator/=(Omega_h::filesystem::path const&) | path& path::operator/=(path const& p) {
impl.push_back(preferred_separator);
impl += p.impl;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x2f, %esi
callq 0x1ca540
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d3f50
movq -0x18(%rbp), %rax
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_filesystem.cpp |
5,014 | Omega_h::filesystem::path::operator/=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | path& path::operator/=(std::string const& s) {
impl.push_back(preferred_separator);
impl += s;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x2f, %esi
callq 0x1ca540
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d3f50
movq -0x18(%rbp), %rax
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_filesystem.cpp |
5,015 | Omega_h::filesystem::path::operator/=(char const*) | path& path::operator/=(const char* s) {
impl.push_back(preferred_separator);
impl += s;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x2f, %esi
callq 0x1ca540
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ccd90
movq -0x18(%rbp), %rax
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_filesystem.cpp |
5,016 | Omega_h::filesystem::path::operator+=(Omega_h::filesystem::path const&) | path& path::operator+=(path const& p) {
impl += p.impl;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d3f50
movq -0x18(%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 | gahansen[P]omega_h/src/Omega_h_filesystem.cpp |
5,017 | Omega_h::filesystem::path::operator+=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | path& path::operator+=(std::string const& s) {
impl += s;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d3f50
movq -0x18(%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 | gahansen[P]omega_h/src/Omega_h_filesystem.cpp |
5,018 | Omega_h::filesystem::path::operator+=(char const*) | path& path::operator+=(const char* s) {
impl += s;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1ccd90
movq -0x18(%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 | gahansen[P]omega_h/src/Omega_h_filesystem.cpp |
5,019 | Omega_h::filesystem::path::operator+=(char) | path& path::operator+=(char c) {
impl.push_back(c);
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movsbl -0x9(%rbp), %esi
callq 0x1ca540
movq -0x18(%rbp), %rax
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_filesystem.cpp |
5,020 | Omega_h::filesystem::operator/(Omega_h::filesystem::path const&, Omega_h::filesystem::path const&) | path operator/(path const& a, path const& b) {
path c = a;
c /= b;
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1cb8d0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c85e0
jmp 0x35bdeb
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x35be17
jmp 0x35be0e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1b9420
jmp 0x35be21
movq -0x38(%rbp), %rdi
callq 0x1b9420
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%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_filesystem.cpp |
5,021 | Omega_h::filesystem::operator<<(std::ostream&, Omega_h::filesystem::path const&) | std::ostream& operator<<(std::ostream& os, path const& p) {
os << p.c_str();
return os;
} | 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 0x1b9690
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x1cd8f0
movq -0x8(%rbp), %rax
addq $0x20, %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_filesystem.cpp |
5,022 | Omega_h::filesystem::filesystem_error::filesystem_error(int, char const*) | filesystem_error::filesystem_error(int ev, const char* what_arg)
: std::system_error(ev, std::system_category(), what_arg) {} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x1c3810
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x1d5990
movq -0x20(%rbp), %rax
movq 0x39c054(%rip), %rcx # 0x6f7f08
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x30, %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_filesystem.cpp |
5,023 | Omega_h::filesystem::file_status::file_status(Omega_h::filesystem::file_type const&) | file_status::file_status(file_type const& type_in) : type_variable(type_in) {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
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_filesystem.cpp |
5,024 | Omega_h::filesystem::file_status::type() const | file_type file_status::type() const noexcept { return type_variable; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
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_filesystem.cpp |
5,025 | Omega_h::filesystem::directory_entry::directory_entry(Omega_h::filesystem::path const&) | directory_entry::directory_entry(class path const& p) : path_variable(p) {} | 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 0x1cb8d0
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_filesystem.cpp |
5,026 | Omega_h::filesystem::directory_entry::is_regular_file() const | bool directory_entry::is_regular_file() const {
return status(path_variable).type() == file_type::regular;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e43d0
movl %eax, -0xc(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1dafe0
cmpl $0x2, %eax
sete %al
andb $0x1, %al
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_filesystem.cpp |
5,027 | Omega_h::filesystem::directory_entry::is_symlink() const | bool directory_entry::is_symlink() const {
return status(path_variable).type() == file_type::symlink;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e43d0
movl %eax, -0xc(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1dafe0
cmpl $0x4, %eax
sete %al
andb $0x1, %al
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_filesystem.cpp |
5,028 | Omega_h::filesystem::directory_iterator::directory_iterator() | directory_iterator::directory_iterator() : impl(new IteratorImpl()) {} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movl $0x30, %edi
callq 0x1cd9b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0x1df650
jmp 0x35bfc3
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, %rdi
callq 0x1c0b70
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x30, %esi
callq 0x1ce050
movq -0x10(%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_filesystem.cpp |
5,029 | Omega_h::filesystem::directory_iterator::directory_iterator(Omega_h::filesystem::directory_iterator&&) | directory_iterator::directory_iterator(directory_iterator&& other) {
delete impl;
impl = other.impl;
other.impl = new IteratorImpl();
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x1c0b70
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x35c05d
movq -0x28(%rbp), %rdi
callq 0x1c0340
movq -0x28(%rbp), %rdi
movl $0x30, %esi
callq 0x1ce050
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movl $0x30, %edi
callq 0x1cd9b0
movq %rax, -0x40(%rbp)
jmp 0x35c07b
movq -0x40(%rbp), %rdi
callq 0x1df650
jmp 0x35c086
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x35c0bf
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x1ce050
movq -0x38(%rbp), %rdi
callq 0x1db250
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_filesystem.cpp |
5,030 | Omega_h::filesystem::directory_iterator::directory_iterator(Omega_h::filesystem::path const&) | directory_iterator::directory_iterator(path const& p)
: impl(new IteratorImpl(p)) {
if (!impl->is_end()) entry = impl->deref();
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movl $0x30, %edi
callq 0x1cd9b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d0060
jmp 0x35c11b
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, %rdi
movq %rdi, -0x68(%rbp)
callq 0x1c0b70
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x1e3400
movb %al, -0x59(%rbp)
jmp 0x35c148
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x35c1b2
jmp 0x35c151
movq -0x50(%rbp), %rax
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1e1fd0
jmp 0x35c163
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
callq 0x1c0400
leaq -0x40(%rbp), %rdi
callq 0x1db250
jmp 0x35c1b2
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x1ce050
jmp 0x35c1b8
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1db250
jmp 0x35c1b8
addq $0x70, %rsp
popq %rbp
retq
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_filesystem.cpp |
5,031 | Omega_h::filesystem::directory_iterator::~directory_iterator() | directory_iterator::~directory_iterator() {
delete impl;
impl = nullptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x35c208
movq -0x10(%rbp), %rdi
callq 0x1c0340
movq -0x10(%rbp), %rdi
movl $0x30, %esi
callq 0x1ce050
movq -0x18(%rbp), %rdi
movq $0x0, (%rdi)
addq $0x8, %rdi
callq 0x1db250
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_filesystem.cpp |
5,032 | Omega_h::filesystem::directory_iterator::operator++() | directory_iterator& directory_iterator::operator++() {
impl->increment();
if (!impl->is_end()) entry = impl->deref();
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rdi
callq 0x1c9140
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x1e3400
testb $0x1, %al
jne 0x35c286
movq -0x30(%rbp), %rax
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1e1fd0
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c0400
leaq -0x28(%rbp), %rdi
callq 0x1db250
movq -0x30(%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_filesystem.cpp |
5,033 | Omega_h::filesystem::directory_iterator::operator*() const | const directory_entry& directory_iterator::operator*() const { return entry; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
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_filesystem.cpp |
5,034 | Omega_h::filesystem::directory_entry::path() const | const filesystem::path& path() const noexcept { return path_variable; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_filesystem.hpp |
5,035 | Omega_h::filesystem::path::path() | path() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d67d0
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_filesystem.hpp |
5,036 | std::system_error::system_error(int, std::_V2::error_category const&, char const*) | system_error(int __v, const error_category& __ecat, const char* __what)
: system_error(error_code(__v, __ecat), __what) { } | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1dab70
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl -0x30(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x1ba4f0
addq $0x40, %rsp
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/system_error |
5,037 | Omega_h::filesystem::IteratorImpl::IteratorImpl() | IteratorImpl() : stream(nullptr), entry(nullptr) {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1c26b0
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%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 | gahansen[P]omega_h/src/Omega_h_filesystem.cpp |
5,038 | Omega_h::filesystem::directory_entry::directory_entry() | directory_entry() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c26b0
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_filesystem.hpp |
5,039 | Omega_h::filesystem::IteratorImpl::~IteratorImpl() | ~IteratorImpl() { close(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1e0710
jmp 0x35c3ab
movq -0x10(%rbp), %rdi
callq 0x1b9420
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_filesystem.cpp |
5,040 | Omega_h::filesystem::directory_entry::~directory_entry() | directory_entry() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b9420
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_filesystem.hpp |
5,041 | Omega_h::filesystem::IteratorImpl::IteratorImpl(Omega_h::filesystem::path const&) | IteratorImpl(path const& p) : root(p), entry(nullptr) {
errno = 0;
stream = ::opendir(p.impl.c_str());
if (stream == nullptr) {
throw filesystem_error(errno, "directory_iterator");
}
increment();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1cb8d0
movq -0x30(%rbp), %rax
movq $0x0, 0x28(%rax)
callq 0x1b88b0
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdi
callq 0x1d9270
movq %rax, -0x28(%rbp)
jmp 0x35c446
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x35c4c2
movl $0x20, %edi
callq 0x1c1200
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
callq 0x1b88b0
movq -0x40(%rbp), %rdi
movl (%rax), %esi
leaq 0x2d4927(%rip), %rdx # 0x630da4
callq 0x1cb7b0
jmp 0x35c484
movq -0x48(%rbp), %rdi
movq 0x39b679(%rip), %rsi # 0x6f7b08
movq 0x39b552(%rip), %rdx # 0x6f79e8
callq 0x1de5c0
jmp 0x35c4e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x35c4d3
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1c6df0
jmp 0x35c4d3
movq -0x38(%rbp), %rdi
callq 0x1c9140
jmp 0x35c4cd
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1b9420
movq -0x18(%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_filesystem.cpp |
5,042 | Omega_h::filesystem::IteratorImpl::is_end() | bool is_end() { return entry == nullptr; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
sete %al
andb $0x1, %al
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_filesystem.cpp |
5,043 | Omega_h::filesystem::IteratorImpl::deref() | directory_entry deref() {
OMEGA_H_CHECK(entry != nullptr);
return directory_entry(root / entry->d_name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, 0x28(%rax)
je 0x35c53f
jmp 0x35c560
leaq 0x2ceb22(%rip), %rdi # 0x62b068
leaq 0x2d486a(%rip), %rsi # 0x630db7
leaq 0x2d4874(%rip), %rdx # 0x630dc8
movl $0xca, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x68(%rbp), %rax
movq 0x28(%rax), %rsi
addq $0x13, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1c36d0
movq -0x68(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1dab00
jmp 0x35c58c
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1e3e60
jmp 0x35c59b
leaq -0x30(%rbp), %rdi
callq 0x1b9420
leaq -0x50(%rbp), %rdi
callq 0x1b9420
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x35c5dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1b9420
leaq -0x50(%rbp), %rdi
callq 0x1b9420
movq -0x58(%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_filesystem.cpp |
5,044 | Omega_h::filesystem::directory_entry::operator=(Omega_h::filesystem::directory_entry&&) | directory_entry() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c6cb0
movq -0x18(%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 | gahansen[P]omega_h/src/Omega_h_filesystem.hpp |
5,045 | Omega_h::filesystem::IteratorImpl::increment() | void increment() {
errno = 0;
entry = ::readdir(stream);
if (entry == nullptr) {
if (errno != 0) {
throw filesystem_error(errno, "directory_iterator");
}
// safely reached the end of the directory
close();
} else {
// we just extracted a good entry from the stream
// skip dot and dot-dot, max 3-call recursion
if (0 == strcmp(entry->d_name, "."))
increment();
else if (0 == strcmp(entry->d_name, ".."))
increment();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x1b88b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl $0x0, (%rcx)
movq 0x20(%rax), %rdi
callq 0x1da110
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, 0x28(%rax)
jne 0x35c6cf
callq 0x1b88b0
cmpl $0x0, (%rax)
je 0x35c6c4
movl $0x20, %edi
callq 0x1c1200
movq %rax, -0x28(%rbp)
movq %rax, -0x30(%rbp)
callq 0x1b88b0
movq -0x28(%rbp), %rdi
movl (%rax), %esi
leaq 0x2d4715(%rip), %rdx # 0x630da4
callq 0x1cb7b0
jmp 0x35c696
movq -0x30(%rbp), %rdi
movq 0x39b467(%rip), %rsi # 0x6f7b08
movq 0x39b340(%rip), %rdx # 0x6f79e8
callq 0x1de5c0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x1c6df0
jmp 0x35c72d
movq -0x20(%rbp), %rdi
callq 0x1e0710
jmp 0x35c727
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
addq $0x13, %rdi
leaq 0x2d08e0(%rip), %rsi # 0x62cfc2
callq 0x1d7030
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x35c6fa
movq -0x20(%rbp), %rdi
callq 0x1c9140
jmp 0x35c725
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
addq $0x13, %rdi
leaq 0x2d4694(%rip), %rsi # 0x630da1
callq 0x1d7030
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x35c723
movq -0x20(%rbp), %rdi
callq 0x1c9140
jmp 0x35c725
jmp 0x35c727
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%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_filesystem.cpp |
5,046 | Omega_h::filesystem::IteratorImpl::equal(Omega_h::filesystem::IteratorImpl const&) const | bool equal(IteratorImpl const& other) const {
if (entry == nullptr && other.entry == nullptr) return true;
if (root.impl != other.root.impl) return false;
return 0 == strcmp(entry->d_name, other.entry->d_name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x28(%rax)
jne 0x35c770
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x35c770
movb $0x1, -0x1(%rbp)
jmp 0x35c7b4
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e0ee0
testb $0x1, %al
jne 0x35c783
jmp 0x35c789
movb $0x0, -0x1(%rbp)
jmp 0x35c7b4
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
addq $0x13, %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
addq $0x13, %rsi
callq 0x1d7030
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
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_filesystem.cpp |
5,047 | std::error_code::error_code(int, std::_V2::error_category const&) | error_code(int __v, const error_category& __cat) noexcept
: _M_value(__v), _M_cat(&__cat) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
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/system_error |
5,048 | std::system_error::system_error(std::error_code, char const*) | system_error(error_code __ec, const char* __what)
: runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { } | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x1d8390
movq -0x98(%rbp), %rdx
leaq 0x2d304d(%rip), %rsi # 0x62f88f
leaq -0x60(%rbp), %rdi
callq 0x1dde30
jmp 0x35c84d
movq -0xa0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x1dde30
jmp 0x35c863
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1d37c0
jmp 0x35c875
leaq -0x40(%rbp), %rdi
callq 0x1c4d10
leaq -0x60(%rbp), %rdi
callq 0x1c4d10
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
movq -0xa8(%rbp), %rax
movq 0x39b69a(%rip), %rcx # 0x6f7f38
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x35c90a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x35c901
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1c4d10
leaq -0x60(%rbp), %rdi
callq 0x1c4d10
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
movq -0x88(%rbp), %rdi
callq 0x1dfa40
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/system_error |
5,049 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> std::operator+<char, std::char_traits<char>, std::allocator<char>>(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | inline basic_string<_CharT, _Traits, _Alloc>
operator+(const _CharT* __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
{ return std::move(__rhs.insert(0, __lhs)); } | 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 -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x1bbe20
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1c4130
movq -0x20(%rbp), %rax
addq $0x30, %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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
5,050 | std::error_code::message[abi:cxx11]() const | explicit operator bool() const noexcept
{ return _M_value != 0; } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1dd770
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x1daeb0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl %eax, %edx
movq (%rsi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %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/system_error |
5,051 | std::error_code::category() const | const error_category&
category() const noexcept { return *_M_cat; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
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/system_error |
5,052 | std::error_code::value() const | int
value() const noexcept { return _M_value; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
popq %rbp
retq
| 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/system_error |
5,053 | Omega_h::filesystem::IteratorImpl::close() | void close() {
if (stream == nullptr) return;
errno = 0;
int err = ::closedir(stream);
stream = nullptr;
if (err != 0) {
throw filesystem_error(errno, "directory_iterator");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x20(%rax)
jne 0x35ca10
jmp 0x35ca9b
callq 0x1b88b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl $0x0, (%rcx)
movq 0x20(%rax), %rdi
callq 0x1dbfe0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq $0x0, 0x20(%rax)
cmpl $0x0, -0xc(%rbp)
je 0x35ca9b
movl $0x20, %edi
callq 0x1c1200
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
callq 0x1b88b0
movq -0x30(%rbp), %rdi
movl (%rax), %esi
leaq 0x2d433e(%rip), %rdx # 0x630da4
callq 0x1cb7b0
jmp 0x35ca6d
movq -0x38(%rbp), %rdi
movq 0x39b090(%rip), %rsi # 0x6f7b08
movq 0x39af69(%rip), %rdx # 0x6f79e8
callq 0x1de5c0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1c6df0
jmp 0x35caa1
addq $0x40, %rsp
popq %rbp
retq
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_filesystem.cpp |
5,054 | bool std::operator!=<char, std::char_traits<char>, std::allocator<char>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
_GLIBCXX_NOEXCEPT
{ return !(__lhs == __rhs); } | 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 0x1c3c00
xorb $-0x1, %al
andb $0x1, %al
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/basic_string.h |
5,055 | Omega_h::FiniteAutomaton::FiniteAutomaton(int, bool, int) | FiniteAutomaton::FiniteAutomaton(
int nsymbols_init, bool is_deterministic_init, int nstates_reserve)
: table(nsymbols_init + (is_deterministic_init ? 0 : 2), nstates_reserve),
is_deterministic(is_deterministic_init) {
reserve(accepted_tokens, nstates_reserve);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movb -0xd(%rbp), %al
notb %al
movzbl %al, %edx
andl $0x1, %edx
movl %ecx, %eax
movl %edx, %ecx
leal (%rax,%rcx,2), %esi
movl -0x14(%rbp), %edx
callq 0x1d51d0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x30(%rbp)
callq 0x1d91a0
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movb -0xd(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x38(%rax)
movl -0x14(%rbp), %esi
callq 0x1c1480
jmp 0x35cb7a
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1c8350
movq -0x38(%rbp), %rdi
callq 0x1c30f0
movq -0x20(%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_finite_automaton.cpp |
5,056 | Omega_h::get_nstates(Omega_h::FiniteAutomaton const&) | int get_nstates(FiniteAutomaton const& fa) { return get_nrows(fa.table); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c2250
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_finite_automaton.cpp |
5,057 | Omega_h::get_nsymbols(Omega_h::FiniteAutomaton const&) | int get_nsymbols(FiniteAutomaton const& fa) {
return get_ncols(fa.table) - (fa.is_deterministic ? 0 : 2);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b9630
movq -0x8(%rbp), %rcx
movb 0x38(%rcx), %sil
movl $0x2, %ecx
xorl %edx, %edx
testb $0x1, %sil
cmovnel %edx, %ecx
subl %ecx, %eax
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_finite_automaton.cpp |
5,058 | Omega_h::get_determinism(Omega_h::FiniteAutomaton const&) | bool get_determinism(FiniteAutomaton const& fa) { return fa.is_deterministic; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x38(%rax), %al
andb $0x1, %al
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_finite_automaton.cpp |
5,059 | Omega_h::get_epsilon0(Omega_h::FiniteAutomaton const&) | int get_epsilon0(FiniteAutomaton const& fa) {
OMEGA_H_CHECK(!fa.is_deterministic);
return get_ncols(fa.table) - 2;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x38(%rax)
jne 0x35cc48
jmp 0x35cc69
leaq 0x2ce419(%rip), %rdi # 0x62b068
leaq 0x2d4200(%rip), %rsi # 0x630e56
leaq 0x2d420e(%rip), %rdx # 0x630e6b
movl $0x1f, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
callq 0x1b9630
subl $0x2, %eax
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_finite_automaton.cpp |
5,060 | Omega_h::get_epsilon1(Omega_h::FiniteAutomaton const&) | int get_epsilon1(FiniteAutomaton const& fa) {
OMEGA_H_CHECK(!fa.is_deterministic);
return get_ncols(fa.table) - 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x38(%rax)
jne 0x35cc98
jmp 0x35ccb9
leaq 0x2ce3c9(%rip), %rdi # 0x62b068
leaq 0x2d41b0(%rip), %rsi # 0x630e56
leaq 0x2d41be(%rip), %rdx # 0x630e6b
movl $0x24, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
callq 0x1b9630
subl $0x1, %eax
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_finite_automaton.cpp |
5,061 | Omega_h::add_state(Omega_h::FiniteAutomaton&) | int add_state(FiniteAutomaton& fa) {
auto state = get_nstates(fa);
resize(fa.table, state + 1, get_ncols(fa.table));
for (int j = 0; j < get_ncols(fa.table); ++j) {
at(fa.table, state, j) = -1;
}
fa.accepted_tokens.push_back(-1);
return state;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b9630
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movl %eax, %edx
callq 0x1d2fa0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b9630
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x35cd4f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x1e0d80
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x35cd17
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
leaq -0x14(%rbp), %rsi
callq 0x1bd4c0
movl -0xc(%rbp), %eax
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_finite_automaton.cpp |
5,062 | Omega_h::add_transition(Omega_h::FiniteAutomaton&, int, int, int) | void add_transition(
FiniteAutomaton& fa, int from_state, int at_symbol, int to_state) {
OMEGA_H_CHECK(0 <= to_state);
OMEGA_H_CHECK(to_state < get_nstates(fa));
OMEGA_H_CHECK(0 <= at_symbol);
OMEGA_H_CHECK(
at_symbol < get_ncols(fa.table)); // allow setting epsilon transitions
OMEGA_H_CHECK(at(fa.table, from_state, at_symbol) == -1);
at(fa.table, from_state, at_symbol) = to_state;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jg 0x35cd8e
jmp 0x35cdaf
leaq 0x2ce2d3(%rip), %rdi # 0x62b068
leaq 0x2d413a(%rip), %rsi # 0x630ed6
leaq 0x2d40c8(%rip), %rdx # 0x630e6b
movl $0x34, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bc9b0
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jge 0x35cdc9
jmp 0x35cdea
leaq 0x2ce298(%rip), %rdi # 0x62b068
leaq 0x2d410d(%rip), %rsi # 0x630ee4
leaq 0x2d408d(%rip), %rdx # 0x630e6b
movl $0x35, %ecx
movb $0x0, %al
callq 0x1ce550
xorl %eax, %eax
cmpl -0x10(%rbp), %eax
jg 0x35cdf3
jmp 0x35ce14
leaq 0x2ce26e(%rip), %rdi # 0x62b068
leaq 0x2d40fe(%rip), %rsi # 0x630eff
leaq 0x2d4063(%rip), %rdx # 0x630e6b
movl $0x36, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b9630
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x35ce2e
jmp 0x35ce4f
leaq 0x2ce233(%rip), %rdi # 0x62b068
leaq 0x2d40d2(%rip), %rsi # 0x630f0e
leaq 0x2d4028(%rip), %rdx # 0x630e6b
movl $0x38, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x1e0d80
cmpl $-0x1, (%rax)
jne 0x35ce65
jmp 0x35ce86
leaq 0x2ce1fc(%rip), %rdi # 0x62b068
leaq 0x2d40bb(%rip), %rsi # 0x630f2e
leaq 0x2d3ff1(%rip), %rdx # 0x630e6b
movl $0x39, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x1e0d80
movl -0x20(%rbp), %ecx
movl %ecx, (%rax)
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_finite_automaton.cpp |
5,063 | Omega_h::add_accept(Omega_h::FiniteAutomaton&, int, int) | void add_accept(FiniteAutomaton& fa, int state, int token) {
OMEGA_H_CHECK(0 <= token);
at(fa.accepted_tokens, state) = token;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorl %eax, %eax
cmpl -0x10(%rbp), %eax
jg 0x35cecb
jmp 0x35ceec
leaq 0x2ce196(%rip), %rdi # 0x62b068
leaq 0x2d407f(%rip), %rsi # 0x630f58
leaq 0x2d3f8b(%rip), %rdx # 0x630e6b
movl $0x3e, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl -0xc(%rbp), %esi
callq 0x1dc3d0
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
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_finite_automaton.cpp |
5,064 | Omega_h::remove_accept(Omega_h::FiniteAutomaton&, int) | void remove_accept(FiniteAutomaton& fa, int state) {
at(fa.accepted_tokens, state) = -1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl -0xc(%rbp), %esi
callq 0x1dc3d0
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
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_finite_automaton.cpp |
5,065 | Omega_h::step(Omega_h::FiniteAutomaton const&, int, int) | int step(FiniteAutomaton const& fa, int state, int symbol) {
OMEGA_H_CHECK(0 <= state);
OMEGA_H_CHECK(state < get_nstates(fa));
OMEGA_H_CHECK(0 <= symbol);
OMEGA_H_CHECK(
symbol < get_ncols(fa.table)); // allow getting epsilon transitions
return at(fa.table, state, symbol);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x35cf5b
jmp 0x35cf7c
leaq 0x2ce106(%rip), %rdi # 0x62b068
leaq 0x2d3ffa(%rip), %rsi # 0x630f63
leaq 0x2d3efb(%rip), %rdx # 0x630e6b
movl $0x47, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bc9b0
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jge 0x35cf96
jmp 0x35cfb7
leaq 0x2ce0cb(%rip), %rdi # 0x62b068
leaq 0x2d3f43(%rip), %rsi # 0x630ee7
leaq 0x2d3ec0(%rip), %rdx # 0x630e6b
movl $0x48, %ecx
movb $0x0, %al
callq 0x1ce550
xorl %eax, %eax
cmpl -0x10(%rbp), %eax
jg 0x35cfc0
jmp 0x35cfe1
leaq 0x2ce0a1(%rip), %rdi # 0x62b068
leaq 0x2d3fa0(%rip), %rsi # 0x630f6e
leaq 0x2d3e96(%rip), %rdx # 0x630e6b
movl $0x49, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b9630
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jge 0x35cffb
jmp 0x35d01c
leaq 0x2ce066(%rip), %rdi # 0x62b068
leaq 0x2d3f08(%rip), %rsi # 0x630f11
leaq 0x2d3e5b(%rip), %rdx # 0x630e6b
movl $0x4b, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x1bcf90
movl (%rax), %eax
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_finite_automaton.cpp |
5,066 | Omega_h::accepts(Omega_h::FiniteAutomaton const&, int) | int accepts(FiniteAutomaton const& fa, int state) {
return at(fa.accepted_tokens, state);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl -0xc(%rbp), %esi
callq 0x1c57d0
movl (%rax), %eax
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 | gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp |
5,067 | Omega_h::get_nsymbols_eps(Omega_h::FiniteAutomaton const&) | int get_nsymbols_eps(FiniteAutomaton const& fa) { return get_ncols(fa.table); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b9630
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_finite_automaton.cpp |
5,068 | Omega_h::append_states(Omega_h::FiniteAutomaton&, Omega_h::FiniteAutomaton const&) | void append_states(FiniteAutomaton& fa, FiniteAutomaton const& other) {
OMEGA_H_CHECK(get_nsymbols(other) == get_nsymbols(fa));
auto other_determ = get_determinism(other);
if (!other_determ) OMEGA_H_CHECK(!fa.is_deterministic);
auto offset = get_nstates(fa);
for (int other_state = 0; other_state < get_nstates(other); ++other_state) {
auto my_state = add_state(fa);
auto token = accepts(other, other_state);
if (0 <= token) add_accept(fa, my_state, token);
}
for (int other_state = 0; other_state < get_nstates(other); ++other_state) {
auto my_state = other_state + offset;
for (int symbol = 0; symbol < get_nsymbols_eps(other); ++symbol) {
auto other_next = step(other, other_state, symbol);
if (other_next < 0) continue;
auto my_next = other_next + offset;
add_transition(fa, my_state, symbol, my_next);
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd200
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dd200
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jne 0x35d0c0
jmp 0x35d0e1
leaq 0x2cdfa1(%rip), %rdi # 0x62b068
leaq 0x2d3eac(%rip), %rsi # 0x630f7a
leaq 0x2d3d96(%rip), %rdx # 0x630e6b
movl $0x56, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x10(%rbp), %rdi
callq 0x1d2d60
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x35d124
movq -0x8(%rbp), %rax
testb $0x1, 0x38(%rax)
jne 0x35d101
jmp 0x35d122
leaq 0x2cdf60(%rip), %rdi # 0x62b068
leaq 0x2d3d47(%rip), %rsi # 0x630e56
leaq 0x2d3d55(%rip), %rdx # 0x630e6b
movl $0x58, %ecx
movb $0x0, %al
callq 0x1ce550
jmp 0x35d124
movq -0x8(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jge 0x35d18d
movq -0x8(%rbp), %rdi
callq 0x1cd730
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1c7120
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl -0x24(%rbp), %eax
jg 0x35d180
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x1d0f10
jmp 0x35d182
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x35d137
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x35d224
movl -0x28(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c3a20
movl %eax, %ecx
movl -0x48(%rbp), %eax
cmpl %ecx, %eax
jge 0x35d214
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x1d6260
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x35d1ee
jmp 0x35d209
movl -0x34(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
movl -0x38(%rbp), %ecx
callq 0x1e0c80
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x35d1bc
jmp 0x35d216
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x35d194
addq $0x50, %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_finite_automaton.cpp |
5,069 | Omega_h::FiniteAutomaton::make_single_nfa(int, int, int) | FiniteAutomaton FiniteAutomaton::make_single_nfa(
int nsymbols, int symbol, int token) {
return FiniteAutomaton::make_range_nfa(nsymbols, symbol, symbol, token);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
callq 0x1ddc70
movq -0x20(%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 | gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp |
5,070 | Omega_h::FiniteAutomaton::make_range_nfa(int, int, int, int) | FiniteAutomaton FiniteAutomaton::make_range_nfa(
int nsymbols, int range_start, int range_end, int token) {
OMEGA_H_CHECK(0 <= range_start);
OMEGA_H_CHECK(range_start <= range_end);
OMEGA_H_CHECK(range_end <= nsymbols);
FiniteAutomaton out(nsymbols, true, 2);
auto start_state = add_state(out);
auto accept_state = add_state(out);
for (int i = range_start; i <= range_end; ++i) {
add_transition(out, start_state, i, accept_state);
}
add_accept(out, accept_state, token);
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
xorl %eax, %eax
cmpl -0x10(%rbp), %eax
jg 0x35d29d
jmp 0x35d2be
leaq 0x2cddc4(%rip), %rdi # 0x62b068
leaq 0x2d3cf7(%rip), %rsi # 0x630fa2
leaq 0x2d3bb9(%rip), %rdx # 0x630e6b
movl $0x7d, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x35d2c8
jmp 0x35d2e9
leaq 0x2cdd99(%rip), %rdi # 0x62b068
leaq 0x2d3cdd(%rip), %rsi # 0x630fb3
leaq 0x2d3b8e(%rip), %rdx # 0x630e6b
movl $0x7e, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x35d2f3
jmp 0x35d314
leaq 0x2cdd6e(%rip), %rdi # 0x62b068
leaq 0x2d3ccb(%rip), %rsi # 0x630fcc
leaq 0x2d3b63(%rip), %rdx # 0x630e6b
movl $0x7f, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x48(%rbp), %rdi
movb $0x0, -0x19(%rbp)
movl -0xc(%rbp), %esi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x1bd6c0
movq -0x48(%rbp), %rdi
callq 0x1cd730
movl %eax, -0x4c(%rbp)
jmp 0x35d33c
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, -0x20(%rbp)
callq 0x1cd730
movl %eax, -0x50(%rbp)
jmp 0x35d350
movl -0x50(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x35d39c
movq -0x48(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x34(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x1e0c80
jmp 0x35d378
jmp 0x35d37a
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x35d35c
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1e02b0
jmp 0x35d3ca
movq -0x48(%rbp), %rdi
movl -0x30(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x1d0f10
jmp 0x35d3ad
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x35d3c0
movq -0x48(%rbp), %rdi
callq 0x1e02b0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%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_finite_automaton.cpp |
5,071 | Omega_h::FiniteAutomaton::make_set_nfa(int, std::set<int, std::less<int>, std::allocator<int>> const&, int) | FiniteAutomaton FiniteAutomaton::make_set_nfa(
int nsymbols, std::set<int> const& accepted, int token) {
FiniteAutomaton out(nsymbols, true, 2);
auto start_state = add_state(out);
auto accept_state = add_state(out);
for (auto i : accepted) {
add_transition(out, start_state, i, accept_state);
}
add_accept(out, accept_state, token);
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movl -0xc(%rbp), %esi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x1bd6c0
movq -0x60(%rbp), %rdi
callq 0x1cd730
movl %eax, -0x58(%rbp)
jmp 0x35d425
movq -0x60(%rbp), %rdi
movl -0x58(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x1cd730
movl %eax, -0x6c(%rbp)
jmp 0x35d439
movl -0x6c(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1c18a0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1cdb90
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1d3840
testb $0x1, %al
jne 0x35d474
jmp 0x35d4ba
leaq -0x48(%rbp), %rdi
callq 0x1d6320
movq -0x60(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x54(%rbp)
movl -0x24(%rbp), %esi
movl -0x54(%rbp), %edx
movl -0x38(%rbp), %ecx
callq 0x1e0c80
jmp 0x35d496
jmp 0x35d498
leaq -0x48(%rbp), %rdi
callq 0x1bf270
jmp 0x35d461
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x1e02b0
jmp 0x35d4e8
movq -0x60(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x1d0f10
jmp 0x35d4cb
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x35d4de
movq -0x60(%rbp), %rdi
callq 0x1e02b0
movq -0x68(%rbp), %rax
addq $0x70, %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_finite_automaton.cpp |
5,072 | Omega_h::FiniteAutomaton::unite(Omega_h::FiniteAutomaton const&, Omega_h::FiniteAutomaton const&) | FiniteAutomaton FiniteAutomaton::unite(
FiniteAutomaton const& a, FiniteAutomaton const& b) {
auto nsymbols = get_nsymbols(a);
FiniteAutomaton out(nsymbols, false, 1 + get_nstates(a) + get_nstates(b));
auto start_state = add_state(out);
auto a_offset = get_nstates(out);
append_states(out, a);
auto b_offset = get_nstates(out);
append_states(out, b);
auto epsilon0 = get_epsilon0(out);
auto epsilon1 = get_epsilon1(out);
add_transition(out, start_state, epsilon0, a_offset);
add_transition(out, start_state, epsilon1, b_offset);
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd200
movl %eax, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1bc9b0
movl -0x58(%rbp), %ecx
movl -0x54(%rbp), %esi
movq -0x50(%rbp), %rdi
movl %eax, %edx
movl %ecx, %eax
movl %edx, %ecx
leal 0x1(%rax,%rcx), %ecx
xorl %edx, %edx
callq 0x1bd6c0
movq -0x50(%rbp), %rdi
callq 0x1cd730
movl %eax, -0x48(%rbp)
jmp 0x35d573
movq -0x50(%rbp), %rdi
movl -0x48(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x1bc9b0
movl %eax, -0x64(%rbp)
jmp 0x35d587
movq -0x50(%rbp), %rdi
movl -0x64(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1daf80
jmp 0x35d59c
movq -0x50(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0x68(%rbp)
jmp 0x35d5aa
movq -0x50(%rbp), %rdi
movl -0x68(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1daf80
jmp 0x35d5bf
movq -0x50(%rbp), %rdi
callq 0x1c09d0
movl %eax, -0x6c(%rbp)
jmp 0x35d5cd
movq -0x50(%rbp), %rdi
movl -0x6c(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0x1bb600
movl %eax, -0x70(%rbp)
jmp 0x35d5e1
movq -0x50(%rbp), %rdi
movl -0x70(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x24(%rbp), %esi
movl -0x40(%rbp), %edx
movl -0x38(%rbp), %ecx
callq 0x1e0c80
jmp 0x35d5fb
movq -0x50(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x44(%rbp), %edx
movl -0x3c(%rbp), %ecx
callq 0x1e0c80
jmp 0x35d60f
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x35d63b
jmp 0x35d632
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x1e02b0
jmp 0x35d645
movq -0x50(%rbp), %rdi
callq 0x1e02b0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%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_finite_automaton.cpp |
5,073 | Omega_h::FiniteAutomaton::concat(Omega_h::FiniteAutomaton const&, Omega_h::FiniteAutomaton const&, int) | FiniteAutomaton FiniteAutomaton::concat(
FiniteAutomaton const& a, FiniteAutomaton const& b, int token) {
auto nsymbols = get_nsymbols(a);
FiniteAutomaton out(nsymbols, false, get_nstates(a) + get_nstates(b));
append_states(out, a);
auto b_offset = get_nstates(out);
append_states(out, b);
auto epsilon0 = get_epsilon0(out);
for (int i = 0; i < get_nstates(a); ++i) {
if (accepts(a, i) != -1) {
add_transition(out, i, epsilon0, b_offset);
remove_accept(out, i);
}
}
for (int i = 0; i < get_nstates(b); ++i) {
if (accepts(b, i) != -1) {
add_accept(out, i + b_offset, token);
}
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd200
movl %eax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1bc9b0
movl -0x58(%rbp), %ecx
movl -0x54(%rbp), %esi
movq -0x50(%rbp), %rdi
addl %eax, %ecx
xorl %edx, %edx
callq 0x1bd6c0
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1daf80
jmp 0x35d6c2
movq -0x50(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0x64(%rbp)
jmp 0x35d6d0
movq -0x50(%rbp), %rdi
movl -0x64(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1daf80
jmp 0x35d6e5
movq -0x50(%rbp), %rdi
callq 0x1c09d0
movl %eax, -0x68(%rbp)
jmp 0x35d6f3
movl -0x68(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0x6c(%rbp)
jmp 0x35d714
movl -0x70(%rbp), %eax
movl -0x6c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x35d785
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0x1c7120
movl %eax, -0x74(%rbp)
jmp 0x35d72f
movl -0x74(%rbp), %eax
cmpl $-0x1, %eax
je 0x35d775
movq -0x50(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x3c(%rbp), %edx
movl -0x38(%rbp), %ecx
callq 0x1e0c80
jmp 0x35d74b
movq -0x50(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0x1c7550
jmp 0x35d759
jmp 0x35d775
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x1e02b0
jmp 0x35d808
jmp 0x35d777
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x35d700
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x7c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0x78(%rbp)
jmp 0x35d7a0
movl -0x7c(%rbp), %eax
movl -0x78(%rbp), %ecx
cmpl %ecx, %eax
jge 0x35d7e8
movq -0x18(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x1c7120
movl %eax, -0x80(%rbp)
jmp 0x35d7bb
movl -0x80(%rbp), %eax
cmpl $-0x1, %eax
je 0x35d7db
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %esi
movl -0x38(%rbp), %eax
addl %eax, %esi
movl -0x1c(%rbp), %edx
callq 0x1d0f10
jmp 0x35d7d9
jmp 0x35d7db
jmp 0x35d7dd
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x35d78c
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x35d7fb
movq -0x50(%rbp), %rdi
callq 0x1e02b0
movq -0x60(%rbp), %rax
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_finite_automaton.cpp |
5,074 | Omega_h::FiniteAutomaton::plus(Omega_h::FiniteAutomaton const&, int) | FiniteAutomaton FiniteAutomaton::plus(FiniteAutomaton const& a, int token) {
FiniteAutomaton out(get_nsymbols(a), false, get_nstates(a) + 1);
append_states(out, a);
auto new_accept_state = add_state(out);
add_accept(out, new_accept_state, token);
auto epsilon0 = get_epsilon0(out);
auto epsilon1 = get_epsilon1(out);
for (int i = 0; i < get_nstates(a); ++i) {
if (accepts(a, i) != -1) {
add_transition(out, i, epsilon0, new_accept_state);
/* we follow a convention that accepting
states should not have epsilon transitions */
add_transition(out, i, epsilon1, 0);
remove_accept(out, i);
}
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd200
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl -0x44(%rbp), %esi
movq -0x40(%rbp), %rdi
movl %eax, %ecx
incl %ecx
xorl %edx, %edx
callq 0x1bd6c0
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1daf80
jmp 0x35d878
movq -0x40(%rbp), %rdi
callq 0x1cd730
movl %eax, -0x54(%rbp)
jmp 0x35d886
movq -0x40(%rbp), %rdi
movl -0x54(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1d0f10
jmp 0x35d89d
movq -0x40(%rbp), %rdi
callq 0x1c09d0
movl %eax, -0x58(%rbp)
jmp 0x35d8ab
movq -0x40(%rbp), %rdi
movl -0x58(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x1bb600
movl %eax, -0x5c(%rbp)
jmp 0x35d8bf
movl -0x5c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0x60(%rbp)
jmp 0x35d8e0
movl -0x64(%rbp), %eax
movl -0x60(%rbp), %ecx
cmpl %ecx, %eax
jge 0x35d961
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1c7120
movl %eax, -0x68(%rbp)
jmp 0x35d8fb
movl -0x68(%rbp), %eax
cmpl $-0x1, %eax
je 0x35d951
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x2c(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0x1e0c80
jmp 0x35d917
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x30(%rbp), %edx
xorl %ecx, %ecx
callq 0x1e0c80
jmp 0x35d92a
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1c7550
jmp 0x35d938
jmp 0x35d951
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1e02b0
jmp 0x35d97e
jmp 0x35d953
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x35d8cc
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x35d974
movq -0x40(%rbp), %rdi
callq 0x1e02b0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%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_finite_automaton.cpp |
5,075 | Omega_h::FiniteAutomaton::maybe(Omega_h::FiniteAutomaton const&, int) | FiniteAutomaton FiniteAutomaton::maybe(FiniteAutomaton const& a, int token) {
FiniteAutomaton out(get_nsymbols(a), false, get_nstates(a) + 2);
auto new_start_state = add_state(out);
auto offset = get_nstates(out);
append_states(out, a);
auto new_accept_state = add_state(out);
auto epsilon0 = get_epsilon0(out);
auto epsilon1 = get_epsilon1(out);
add_transition(out, new_start_state, epsilon1, offset);
/* form an epsilon0 linked list of new start state,
all old accepting states, and new accepting state */
auto last = new_start_state;
for (int i = 0; i < get_nstates(a); ++i) {
if (accepts(a, i) != -1) {
add_transition(out, last, epsilon0, i + offset);
remove_accept(out, i + offset);
last = i + offset;
}
}
add_transition(out, last, epsilon0, new_accept_state);
add_accept(out, new_accept_state, token);
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd200
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl -0x54(%rbp), %esi
movq -0x50(%rbp), %rdi
movl %eax, %ecx
addl $0x2, %ecx
xorl %edx, %edx
callq 0x1bd6c0
movq -0x50(%rbp), %rdi
callq 0x1cd730
movl %eax, -0x48(%rbp)
jmp 0x35d9eb
movq -0x50(%rbp), %rdi
movl -0x48(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x1bc9b0
movl %eax, -0x64(%rbp)
jmp 0x35d9ff
movq -0x50(%rbp), %rdi
movl -0x64(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1daf80
jmp 0x35da14
movq -0x50(%rbp), %rdi
callq 0x1cd730
movl %eax, -0x68(%rbp)
jmp 0x35da22
movq -0x50(%rbp), %rdi
movl -0x68(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x1c09d0
movl %eax, -0x6c(%rbp)
jmp 0x35da36
movq -0x50(%rbp), %rdi
movl -0x6c(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0x1bb600
movl %eax, -0x70(%rbp)
jmp 0x35da4a
movq -0x50(%rbp), %rdi
movl -0x70(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x1c(%rbp), %esi
movl -0x3c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x1e0c80
jmp 0x35da64
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0x74(%rbp)
jmp 0x35da85
movl -0x78(%rbp), %eax
movl -0x74(%rbp), %ecx
cmpl %ecx, %eax
jge 0x35db06
movq -0x10(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x1c7120
movl %eax, -0x7c(%rbp)
jmp 0x35daa0
movl -0x7c(%rbp), %eax
cmpl $-0x1, %eax
je 0x35daf6
movq -0x50(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x38(%rbp), %edx
movl -0x44(%rbp), %ecx
movl -0x30(%rbp), %eax
addl %eax, %ecx
callq 0x1e0c80
jmp 0x35dac1
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %esi
movl -0x30(%rbp), %eax
addl %eax, %esi
callq 0x1c7550
jmp 0x35dad4
movl -0x44(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x35daf6
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1e02b0
jmp 0x35db4b
jmp 0x35daf8
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x35da71
movq -0x50(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x38(%rbp), %edx
movl -0x34(%rbp), %ecx
callq 0x1e0c80
jmp 0x35db1a
movq -0x50(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1d0f10
jmp 0x35db2b
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x35db3e
movq -0x50(%rbp), %rdi
callq 0x1e02b0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%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_finite_automaton.cpp |
5,076 | Omega_h::FiniteAutomaton::star(Omega_h::FiniteAutomaton const&, int) | FiniteAutomaton FiniteAutomaton::star(FiniteAutomaton const& a, int token) {
return maybe(plus(a, token), token);
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1e4550
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1c9ed0
jmp 0x35dba7
leaq -0x58(%rbp), %rdi
callq 0x1e02b0
movq -0x80(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1e02b0
movq -0x60(%rbp), %rdi
callq 0x1dfa40
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_finite_automaton.cpp |
5,077 | Omega_h::FiniteAutomaton::make_deterministic(Omega_h::FiniteAutomaton const&) | FiniteAutomaton FiniteAutomaton::make_deterministic(
FiniteAutomaton const& nfa) {
if (get_determinism(nfa)) return nfa;
StateSetPtr2State ssp2s;
StateSetUniqPtrVector ssupv;
FiniteAutomaton out(get_nsymbols(nfa), true, 0);
StateSet start_ss;
start_ss.insert(0);
start_ss = get_epsilon_closure(start_ss, nfa);
emplace_back(ssupv, start_ss);
ssp2s[ssupv.back().get()] = add_state(out);
int front = 0;
while (front < int(ssupv.size())) {
auto state = front;
auto& ss = *at(ssupv, front);
++front;
for (int symbol = 0; symbol < get_nsymbols(nfa); ++symbol) {
auto next_ss = Omega_h::step(ss, symbol, nfa);
if (next_ss.empty()) continue;
next_ss = get_epsilon_closure(next_ss, nfa);
int next_state;
auto it = ssp2s.find(&next_ss);
if (it == ssp2s.end()) {
next_state = add_state(out);
emplace_back(ssupv, next_ss);
ssp2s[ssupv.back().get()] = next_state;
} else {
next_state = it->second;
}
add_transition(out, state, symbol, next_state);
}
int min_accepted = -1;
for (auto nfa_state : ss) {
auto nfa_token = accepts(nfa, nfa_state);
if (nfa_token == -1) continue;
if (min_accepted == -1 || nfa_token < min_accepted) {
min_accepted = nfa_token;
}
}
if (min_accepted != -1) add_accept(out, state, min_accepted);
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdi, -0x230(%rbp)
movq %rdi, %rax
movq %rax, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d2d60
testb $0x1, %al
jne 0x35dc13
jmp 0x35dc28
movq -0x230(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d8570
jmp 0x35e22c
leaq -0x40(%rbp), %rdi
callq 0x1da700
leaq -0x58(%rbp), %rdi
callq 0x1be300
movb $0x0, -0x59(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd200
movl %eax, -0x234(%rbp)
jmp 0x35dc4f
movl -0x234(%rbp), %esi
movq -0x230(%rbp), %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1bd6c0
jmp 0x35dc6a
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x1d1af0
movq -0x250(%rbp), %rdi
movl $0x0, -0xa4(%rbp)
leaq -0xa4(%rbp), %rsi
callq 0x1e2100
movb %dl, -0x241(%rbp)
movq %rax, -0x240(%rbp)
jmp 0x35dca9
movb -0x241(%rbp), %al
movq -0x240(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
movb %al, -0xb0(%rbp)
leaq -0x118(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1cbd40
jmp 0x35dcd8
movq -0x10(%rbp), %rdx
leaq -0xe8(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x35e250
jmp 0x35dcf1
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x258(%rbp)
leaq -0xe8(%rbp), %rsi
movq %rsi, -0x260(%rbp)
callq 0x1bb680
movq -0x260(%rbp), %rdi
callq 0x1bb120
leaq -0x118(%rbp), %rdi
callq 0x1bb120
movq -0x258(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x35e4c0
jmp 0x35dd3c
movq -0x230(%rbp), %rdi
callq 0x1cd730
movl %eax, -0x264(%rbp)
jmp 0x35dd50
leaq -0x58(%rbp), %rdi
callq 0x1d4d20
movq %rax, %rdi
callq 0x1d9950
movq %rax, -0x120(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x1d85a0
movq %rax, -0x270(%rbp)
jmp 0x35dd81
movq -0x270(%rbp), %rax
movl -0x264(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, -0x124(%rbp)
movl -0x124(%rbp), %eax
movl %eax, -0x274(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1bb140
movq %rax, %rcx
movl -0x274(%rbp), %eax
cmpl %ecx, %eax
jge 0x35e1bc
movl -0x124(%rbp), %eax
movl %eax, -0x128(%rbp)
movl -0x124(%rbp), %esi
leaq -0x58(%rbp), %rdi
callq 0x1c1170
movq %rax, -0x280(%rbp)
jmp 0x35dde4
movq -0x280(%rbp), %rdi
callq 0x1c7930
movq %rax, -0x288(%rbp)
jmp 0x35ddf9
movq -0x288(%rbp), %rax
movq %rax, -0x130(%rbp)
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
movl $0x0, -0x134(%rbp)
movl -0x134(%rbp), %eax
movl %eax, -0x290(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd200
movl %eax, -0x28c(%rbp)
jmp 0x35de3d
movl -0x290(%rbp), %eax
movl -0x28c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x35e0c3
movq -0x130(%rbp), %rsi
movl -0x134(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq -0x168(%rbp), %rdi
callq 0x35e540
jmp 0x35de70
leaq -0x168(%rbp), %rdi
callq 0x1b8550
testb $0x1, %al
jne 0x35de82
jmp 0x35ded0
movl $0x6, -0x16c(%rbp)
jmp 0x35e082
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x35e218
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x35e1de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x1bb120
jmp 0x35e1de
leaq -0x1d0(%rbp), %rdi
leaq -0x168(%rbp), %rsi
callq 0x1cbd40
jmp 0x35dee5
movq -0x10(%rbp), %rdx
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x35e250
jmp 0x35defe
leaq -0x168(%rbp), %rdi
movq %rdi, -0x2a0(%rbp)
leaq -0x1a0(%rbp), %rsi
movq %rsi, -0x2a8(%rbp)
callq 0x1bb680
movq -0x2a8(%rbp), %rdi
callq 0x1bb120
leaq -0x1d0(%rbp), %rdi
callq 0x1bb120
movq -0x2a0(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x1d7ce0
movq %rax, -0x298(%rbp)
jmp 0x35df5e
movq -0x298(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1c7db0
movq %rax, -0x1f0(%rbp)
leaq -0x1e0(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x1ce830
testb $0x1, %al
jne 0x35df98
jmp 0x35e043
movq -0x230(%rbp), %rdi
callq 0x1cd730
movl %eax, -0x2ac(%rbp)
jmp 0x35dfac
movl -0x2ac(%rbp), %eax
movl %eax, -0x1d4(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x168(%rbp), %rsi
callq 0x35e4c0
jmp 0x35dfca
movl -0x1d4(%rbp), %eax
movl %eax, -0x2bc(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1d4d20
movq %rax, %rdi
callq 0x1d9950
movq %rax, -0x1f8(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x1d85a0
movq %rax, -0x2b8(%rbp)
jmp 0x35e007
movq -0x2b8(%rbp), %rax
movl -0x2bc(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x35e058
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x35e0b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x1bb120
jmp 0x35e0b2
leaq -0x1e0(%rbp), %rdi
callq 0x1d59f0
movl 0x8(%rax), %eax
movl %eax, -0x1d4(%rbp)
movq -0x230(%rbp), %rdi
movl -0x128(%rbp), %esi
movl -0x134(%rbp), %edx
movl -0x1d4(%rbp), %ecx
callq 0x1e0c80
jmp 0x35e078
movl $0x0, -0x16c(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x1bb120
movl -0x16c(%rbp), %eax
testl %eax, %eax
je 0x35e09c
jmp 0x35e09a
jmp 0x35e09e
jmp 0x35e09e
movl -0x134(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x134(%rbp)
jmp 0x35de20
leaq -0x168(%rbp), %rdi
callq 0x1bb120
jmp 0x35e1de
movl $0xffffffff, -0x1fc(%rbp) # imm = 0xFFFFFFFF
movq -0x130(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rdi
callq 0x1c18a0
movq %rax, -0x210(%rbp)
movq -0x208(%rbp), %rdi
callq 0x1cdb90
movq %rax, -0x218(%rbp)
leaq -0x210(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x1d3840
testb $0x1, %al
jne 0x35e11a
jmp 0x35e192
leaq -0x210(%rbp), %rdi
callq 0x1d6320
movl (%rax), %eax
movl %eax, -0x21c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x21c(%rbp), %esi
callq 0x1c7120
movl %eax, -0x2c0(%rbp)
jmp 0x35e145
movl -0x2c0(%rbp), %eax
movl %eax, -0x220(%rbp)
cmpl $-0x1, -0x220(%rbp)
jne 0x35e15c
jmp 0x35e181
cmpl $-0x1, -0x1fc(%rbp)
je 0x35e173
movl -0x220(%rbp), %eax
cmpl -0x1fc(%rbp), %eax
jge 0x35e17f
movl -0x220(%rbp), %eax
movl %eax, -0x1fc(%rbp)
jmp 0x35e181
leaq -0x210(%rbp), %rdi
callq 0x1bf270
jmp 0x35e101
cmpl $-0x1, -0x1fc(%rbp)
je 0x35e1b7
movq -0x230(%rbp), %rdi
movl -0x128(%rbp), %esi
movl -0x1fc(%rbp), %edx
callq 0x1d0f10
jmp 0x35e1b5
jmp 0x35e1b7
jmp 0x35dd9a
movb $0x1, -0x59(%rbp)
movl $0x1, -0x16c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1bb120
testb $0x1, -0x59(%rbp)
jne 0x35e204
jmp 0x35e1f8
leaq -0xa0(%rbp), %rdi
callq 0x1bb120
movq -0x230(%rbp), %rdi
callq 0x1e02b0
jmp 0x35e218
movq -0x230(%rbp), %rdi
callq 0x1e02b0
leaq -0x58(%rbp), %rdi
callq 0x1ca440
leaq -0x40(%rbp), %rdi
callq 0x1e28d0
jmp 0x35e22c
leaq -0x58(%rbp), %rdi
callq 0x1ca440
leaq -0x40(%rbp), %rdi
callq 0x1e28d0
jmp 0x35e23c
movq -0x228(%rbp), %rax
addq $0x2c0, %rsp # imm = 0x2C0
popq %rbp
retq
movq -0x68(%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_finite_automaton.cpp |
5,078 | Omega_h::get_epsilon_closure(std::set<int, std::less<int>, std::allocator<int>>, Omega_h::FiniteAutomaton const&) | static StateSet get_epsilon_closure(StateSet ss, FiniteAutomaton const& fa) {
StateQueue q;
for (auto state : ss) q.push(state);
auto epsilon0 = get_epsilon0(fa);
auto epsilon1 = get_epsilon1(fa);
while (!q.empty()) {
auto state = q.front();
q.pop();
for (auto epsilon = epsilon0; epsilon <= epsilon1; ++epsilon) {
auto next_state = step(fa, state, epsilon);
if (next_state == -1) continue;
if (!ss.count(next_state)) {
ss.insert(next_state);
q.push(next_state);
}
}
}
return ss;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rsi, -0xc0(%rbp)
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1dc940
movq -0xc0(%rbp), %rsi
movq %rsi, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x1c18a0
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
callq 0x1cdb90
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1d3840
testb $0x1, %al
jne 0x35e2c0
jmp 0x35e310
leaq -0x78(%rbp), %rdi
callq 0x1d6320
movl (%rax), %eax
movl %eax, -0x84(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x84(%rbp), %rsi
callq 0x1d60d0
jmp 0x35e2e3
jmp 0x35e2e5
leaq -0x78(%rbp), %rdi
callq 0x1bf270
jmp 0x35e2ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1cfca0
jmp 0x35e4aa
movq -0x18(%rbp), %rdi
callq 0x1c09d0
movl %eax, -0xd4(%rbp)
jmp 0x35e321
movl -0xd4(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1bb600
movl %eax, -0xd8(%rbp)
jmp 0x35e33e
movl -0xd8(%rbp), %eax
movl %eax, -0x9c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1d5ba0
movb %al, -0xd9(%rbp)
jmp 0x35e35b
movb -0xd9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x35e36c
jmp 0x35e47e
leaq -0x68(%rbp), %rdi
callq 0x1becf0
movq %rax, -0xe8(%rbp)
jmp 0x35e37e
movq -0xe8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xa0(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c3670
jmp 0x35e398
movl -0x98(%rbp), %eax
movl %eax, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
cmpl -0x9c(%rbp), %eax
jg 0x35e479
movq -0x18(%rbp), %rdi
movl -0xa0(%rbp), %esi
movl -0xa4(%rbp), %edx
callq 0x1d6260
movl %eax, -0xec(%rbp)
jmp 0x35e3d3
movl -0xec(%rbp), %eax
movl %eax, -0xa8(%rbp)
cmpl $-0x1, -0xa8(%rbp)
jne 0x35e3ea
jmp 0x35e465
movq -0xc0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1e0ec0
movq %rax, -0xf8(%rbp)
jmp 0x35e406
movq -0xf8(%rbp), %rax
cmpq $0x0, %rax
jne 0x35e463
movq -0xc0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1c1f90
movb %dl, -0x101(%rbp)
movq %rax, -0x100(%rbp)
jmp 0x35e435
movb -0x101(%rbp), %al
movq -0x100(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
movb %al, -0xb0(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1d60d0
jmp 0x35e461
jmp 0x35e463
jmp 0x35e465
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x35e3a4
jmp 0x35e34a
movq -0xc0(%rbp), %rsi
movq -0xd0(%rbp), %rdi
callq 0x1b9e20
leaq -0x68(%rbp), %rdi
callq 0x1cfca0
movq -0xc8(%rbp), %rax
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
movq -0x90(%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_finite_automaton.cpp |
5,079 | Omega_h::emplace_back(std::vector<std::unique_ptr<std::set<int, std::less<int>, std::allocator<int>>, std::default_delete<std::set<int, std::less<int>, std::allocator<int>>>>, std::allocator<std::unique_ptr<std::set<int, std::less<int>, std::allocator<int>>, std::default_delete<std::set<int, std::less<int>, std::allocator<int>>>>>>&, std::set<int, std::less<int>, std::allocator<int>>&) | static void emplace_back(StateSetUniqPtrVector& ssupv, StateSet& ss) {
ssupv.push_back(std::unique_ptr<StateSet>(new StateSet(std::move(ss))));
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x30, %edi
callq 0x1cd9b0
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1b9e20
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1d0860
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1c5df0
jmp 0x35e512
leaq -0x18(%rbp), %rdi
callq 0x1cf740
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1cf740
movq -0x20(%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_finite_automaton.cpp |
5,080 | Omega_h::step(std::set<int, std::less<int>, std::allocator<int>> const&, int, Omega_h::FiniteAutomaton const&) | static StateSet step(
StateSet const& ss, int symbol, FiniteAutomaton const& fa) {
StateSet next_ss;
for (auto state : ss) {
auto next_state = step(fa, state, symbol);
if (next_state != -1) next_ss.insert(next_state);
}
return next_ss;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x1d1af0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1c18a0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1cdb90
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1d3840
testb $0x1, %al
jne 0x35e5a6
jmp 0x35e62d
leaq -0x38(%rbp), %rdi
callq 0x1d6320
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
movl -0x44(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1d6260
movl %eax, -0x7c(%rbp)
jmp 0x35e5c8
movl -0x7c(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $-0x1, -0x48(%rbp)
je 0x35e61d
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c1f90
movb %dl, -0x89(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x35e5f0
movb -0x89(%rbp), %al
movq -0x88(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movb %al, -0x60(%rbp)
jmp 0x35e61d
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x1bb120
jmp 0x35e64d
jmp 0x35e61f
leaq -0x38(%rbp), %rdi
callq 0x1bf270
jmp 0x35e590
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x35e640
movq -0x78(%rbp), %rdi
callq 0x1bb120
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%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_finite_automaton.cpp |
5,081 | Omega_h::FiniteAutomaton::simplify_once(Omega_h::FiniteAutomaton const&) | FiniteAutomaton FiniteAutomaton::simplify_once(FiniteAutomaton const& fa) {
StateRow2SimpleState sr2ss({fa.table, fa.accepted_tokens});
int nsimple = 0;
for (int state = 0; state < get_nstates(fa); ++state) {
auto res = sr2ss.insert(std::make_pair(state, nsimple));
if (res.second) {
++nsimple;
}
}
FiniteAutomaton out(get_nsymbols(fa), get_determinism(fa), nsimple);
for (int simple = 0; simple < nsimple; ++simple) {
add_state(out);
}
std::vector<bool> did_simple(size_t(nsimple), false);
for (int state = 0; state < get_nstates(fa); ++state) {
OMEGA_H_CHECK(sr2ss.count(state));
auto simple = sr2ss[state];
if (at(did_simple, simple)) continue;
for (int symbol = 0; symbol < get_nsymbols_eps(fa); ++symbol) {
auto next_state = step(fa, state, symbol);
if (next_state == -1) continue;
OMEGA_H_CHECK(sr2ss.count(next_state));
auto next_simple = sr2ss[next_state];
add_transition(out, simple, symbol, next_simple);
}
auto token = accepts(fa, state);
if (token != -1) {
add_accept(out, simple, token);
}
at(did_simple, simple) = true;
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x128(%rbp)
movq %rdi, %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x50(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x1d6790
movq -0x118(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1e0260
jmp 0x35e6be
leaq -0x59(%rbp), %rdi
callq 0x1c83e0
movl $0x0, -0x70(%rbp)
movl $0x0, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl %eax, -0x130(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0x12c(%rbp)
jmp 0x35e6ef
movl -0x130(%rbp), %eax
movl -0x12c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x35e7c3
leaq -0x74(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1c2de0
movq %rax, -0x138(%rbp)
jmp 0x35e719
movq -0x138(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1b92b0
movb %dl, -0x141(%rbp)
movq %rax, -0x140(%rbp)
jmp 0x35e746
movb -0x141(%rbp), %al
movq -0x140(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movb %al, -0x98(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x88(%rbp)
movb -0x98(%rbp), %al
movb %al, -0x80(%rbp)
testb $0x1, -0x80(%rbp)
je 0x35e7b3
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x35e7b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x1c83e0
jmp 0x35ebf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x35ebe9
jmp 0x35e7b5
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x35e6d5
movb $0x0, -0xa1(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd200
movl %eax, -0x148(%rbp)
jmp 0x35e7db
movq -0x10(%rbp), %rdi
callq 0x1d2d60
movq -0x128(%rbp), %rdi
movl -0x148(%rbp), %esi
movl -0x70(%rbp), %ecx
movzbl %al, %edx
callq 0x1bd6c0
jmp 0x35e7fe
movl $0x0, -0xa8(%rbp)
movl -0xa8(%rbp), %eax
cmpl -0x70(%rbp), %eax
jge 0x35e845
movq -0x128(%rbp), %rdi
callq 0x1cd730
jmp 0x35e821
jmp 0x35e823
movl -0xa8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa8(%rbp)
jmp 0x35e808
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x35ebdd
movslq -0x70(%rbp), %rax
movq %rax, -0x158(%rbp)
movb $0x0, -0xd1(%rbp)
leaq -0xd2(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x1d5060
movq -0x158(%rbp), %rsi
movq -0x150(%rbp), %rcx
leaq -0xd0(%rbp), %rdi
leaq -0xd1(%rbp), %rdx
callq 0x1d3540
jmp 0x35e88d
leaq -0xd2(%rbp), %rdi
callq 0x1e3c30
movl $0x0, -0xd8(%rbp)
movl -0xd8(%rbp), %eax
movl %eax, -0x160(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0x15c(%rbp)
jmp 0x35e8c0
movl -0x160(%rbp), %eax
movl -0x15c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x35eb9c
leaq -0x48(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1be760
movq %rax, -0x168(%rbp)
jmp 0x35e8ed
movq -0x168(%rbp), %rax
cmpq $0x0, %rax
je 0x35e8fc
jmp 0x35e959
leaq 0x2cc765(%rip), %rdi # 0x62b068
leaq 0x2d26d8(%rip), %rsi # 0x630fe2
leaq 0x2d255a(%rip), %rdx # 0x630e6b
xorl %eax, %eax
movl $0x15e, %ecx # imm = 0x15E
callq 0x1ce550
jmp 0x35e91f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xd2(%rbp), %rdi
callq 0x1e3c30
jmp 0x35ebdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1c1f50
jmp 0x35ebdd
leaq -0x48(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1bcbb0
movq %rax, -0x170(%rbp)
jmp 0x35e972
movq -0x170(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xdc(%rbp)
movl -0xdc(%rbp), %esi
leaq -0xd0(%rbp), %rdi
callq 0x1bb780
movq %rdx, -0x180(%rbp)
movq %rax, -0x178(%rbp)
jmp 0x35e9a3
movq -0x180(%rbp), %rax
movq -0x178(%rbp), %rcx
movq %rcx, -0xf0(%rbp)
movq %rax, -0xe8(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x1bb190
testb $0x1, %al
jne 0x35e9d1
jmp 0x35e9d6
jmp 0x35eb88
movl $0x0, -0xf4(%rbp)
movl -0xf4(%rbp), %eax
movl %eax, -0x188(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c3a20
movl %eax, -0x184(%rbp)
jmp 0x35e9fd
movl -0x188(%rbp), %eax
movl -0x184(%rbp), %ecx
cmpl %ecx, %eax
jge 0x35eaf1
movq -0x10(%rbp), %rdi
movl -0xd8(%rbp), %esi
movl -0xf4(%rbp), %edx
callq 0x1d6260
movl %eax, -0x18c(%rbp)
jmp 0x35ea2e
movl -0x18c(%rbp), %eax
movl %eax, -0xf8(%rbp)
cmpl $-0x1, -0xf8(%rbp)
jne 0x35ea48
jmp 0x35eadd
leaq -0x48(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x1be760
movq %rax, -0x198(%rbp)
jmp 0x35ea61
movq -0x198(%rbp), %rax
cmpq $0x0, %rax
je 0x35ea70
jmp 0x35ea93
leaq 0x2cc5f1(%rip), %rdi # 0x62b068
leaq 0x2d2577(%rip), %rsi # 0x630ff5
leaq 0x2d23e6(%rip), %rdx # 0x630e6b
xorl %eax, %eax
movl $0x164, %ecx # imm = 0x164
callq 0x1ce550
jmp 0x35ea93
leaq -0x48(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x1bcbb0
movq %rax, -0x1a0(%rbp)
jmp 0x35eaac
movq -0x128(%rbp), %rdi
movq -0x1a0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xfc(%rbp)
movl -0xdc(%rbp), %esi
movl -0xf4(%rbp), %edx
movl -0xfc(%rbp), %ecx
callq 0x1e0c80
jmp 0x35eadb
jmp 0x35eadd
movl -0xf4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xf4(%rbp)
jmp 0x35e9e0
movq -0x10(%rbp), %rdi
movl -0xd8(%rbp), %esi
callq 0x1c7120
movl %eax, -0x1a4(%rbp)
jmp 0x35eb08
movl -0x1a4(%rbp), %eax
movl %eax, -0x100(%rbp)
cmpl $-0x1, -0x100(%rbp)
je 0x35eb39
movq -0x128(%rbp), %rdi
movl -0xdc(%rbp), %esi
movl -0x100(%rbp), %edx
callq 0x1d0f10
jmp 0x35eb37
jmp 0x35eb39
movl -0xdc(%rbp), %esi
leaq -0xd0(%rbp), %rdi
callq 0x1bb780
movq %rdx, -0x1b8(%rbp)
movq %rax, -0x1b0(%rbp)
jmp 0x35eb5b
movq -0x1b8(%rbp), %rax
movq -0x1b0(%rbp), %rcx
movq %rcx, -0x110(%rbp)
movq %rax, -0x108(%rbp)
leaq -0x110(%rbp), %rdi
movl $0x1, %esi
callq 0x1c3490
movl -0xd8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xd8(%rbp)
jmp 0x35e8a3
movb $0x1, -0xa1(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1c1f50
testb $0x1, -0xa1(%rbp)
jne 0x35ebc4
movq -0x128(%rbp), %rdi
callq 0x1e02b0
leaq -0x48(%rbp), %rdi
callq 0x1cc160
movq -0x120(%rbp), %rax
addq $0x1c0, %rsp # imm = 0x1C0
popq %rbp
retq
movq -0x128(%rbp), %rdi
callq 0x1e02b0
leaq -0x48(%rbp), %rdi
callq 0x1cc160
movq -0x68(%rbp), %rdi
callq 0x1dfa40
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_finite_automaton.cpp |
5,082 | Omega_h::FiniteAutomaton::simplify(Omega_h::FiniteAutomaton const&) | FiniteAutomaton FiniteAutomaton::simplify(FiniteAutomaton const& fa) {
FiniteAutomaton out = fa;
int nstates_new = get_nstates(fa);
int nstates;
int i = 0;
do {
nstates = nstates_new;
out = FiniteAutomaton::simplify_once(out);
++i;
nstates_new = get_nstates(out);
} while (nstates_new < nstates);
if (i > 2) std::cerr << "simplify() actually took multiple steps!\n";
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d8570
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl %eax, -0x74(%rbp)
jmp 0x35ec3c
movl -0x74(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x88(%rbp), %rsi
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1d9280
jmp 0x35ec61
movq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %rsi, -0x98(%rbp)
callq 0x1cd7d0
movq -0x98(%rbp), %rdi
callq 0x1e02b0
movq -0x88(%rbp), %rdi
movl -0x2c(%rbp), %eax
incl %eax
movl %eax, -0x2c(%rbp)
callq 0x1bc9b0
movl %eax, -0x8c(%rbp)
jmp 0x35eca0
movl -0x8c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x28(%rbp), %eax
jl 0x35ec49
cmpl $0x2, -0x2c(%rbp)
jle 0x35ece8
movq 0x39931a(%rip), %rdi # 0x6f7fd8
leaq 0x2d2348(%rip), %rsi # 0x63100d
callq 0x1cd8f0
jmp 0x35eccc
jmp 0x35ece8
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1e02b0
jmp 0x35ed0b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x35ecfe
movq -0x88(%rbp), %rdi
callq 0x1e02b0
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x20(%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_finite_automaton.cpp |
5,083 | Omega_h::make_char_nfa(bool, int) | FiniteAutomaton make_char_nfa(bool is_deterministic_init, int nstates_reserve) {
return FiniteAutomaton(
Omega_h::NCHARS, is_deterministic_init, nstates_reserve);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movb -0x9(%rbp), %al
movl -0x10(%rbp), %ecx
movl $0x62, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0x1bd6c0
movq -0x18(%rbp), %rax
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_finite_automaton.cpp |
5,084 | Omega_h::add_char_transition(Omega_h::FiniteAutomaton&, int, char, int) | void add_char_transition(
FiniteAutomaton& fa, int from_state, char at_char, int to_state) {
add_transition(fa, from_state, get_symbol(at_char), to_state);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movsbl -0xd(%rbp), %edi
callq 0x1c3150
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movl %eax, %edx
movl -0x14(%rbp), %ecx
callq 0x1e0c80
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_finite_automaton.cpp |
5,085 | Omega_h::get_symbol(char) | int get_symbol(char c) { return GetSymbol<char>::eval(c); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %edi
callq 0x1e0c10
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_finite_automaton.cpp |
5,086 | Omega_h::is_symbol(char) | bool is_symbol(char c) { return IsSymbol<char>::eval(c); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %edi
callq 0x1d1ee0
andb $0x1, %al
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_finite_automaton.cpp |
5,087 | Omega_h::get_char(int) | char get_char(int symbol) {
OMEGA_H_CHECK(0 <= symbol);
OMEGA_H_CHECK(symbol < Omega_h::NCHARS);
return inv_chartab[symbol];
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
xorl %eax, %eax
cmpl -0x4(%rbp), %eax
jg 0x35ee04
jmp 0x35ee25
leaq 0x2cc25d(%rip), %rdi # 0x62b068
leaq 0x2d215c(%rip), %rsi # 0x630f6e
leaq 0x2d2052(%rip), %rdx # 0x630e6b
movl $0x1b8, %ecx # imm = 0x1B8
movb $0x0, %al
callq 0x1ce550
cmpl $0x62, -0x4(%rbp)
jge 0x35ee2d
jmp 0x35ee4e
leaq 0x2cc234(%rip), %rdi # 0x62b068
leaq 0x2d21fc(%rip), %rsi # 0x631037
leaq 0x2d2029(%rip), %rdx # 0x630e6b
movl $0x1b9, %ecx # imm = 0x1B9
movb $0x0, %al
callq 0x1ce550
movslq -0x4(%rbp), %rcx
movq 0x399107(%rip), %rax # 0x6f7f60
movb (%rax,%rcx), %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_finite_automaton.cpp |
5,088 | Omega_h::make_char_set_nfa(std::set<char, std::less<char>, std::allocator<char>> const&, int) | FiniteAutomaton make_char_set_nfa(std::set<char> const& accepted, int token) {
std::set<int> symbol_set;
for (auto c : accepted) symbol_set.insert(get_symbol(c));
return FiniteAutomaton::make_set_nfa(Omega_h::NCHARS, symbol_set, token);
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1d1af0
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1d1950
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1dbb90
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1b9580
testb $0x1, %al
jne 0x35eed5
jmp 0x35ef52
leaq -0x58(%rbp), %rdi
callq 0x1e10b0
movb (%rax), %al
movb %al, -0x61(%rbp)
movsbl -0x61(%rbp), %edi
callq 0x1c3150
movl %eax, -0x9c(%rbp)
jmp 0x35eef4
movl -0x9c(%rbp), %eax
movl %eax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1e2100
movb %dl, -0xa9(%rbp)
movq %rax, -0xa8(%rbp)
jmp 0x35ef19
movb -0xa9(%rbp), %al
movq -0xa8(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movb %al, -0x80(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1dbcf0
jmp 0x35eec2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1bb120
jmp 0x35ef85
movq -0x98(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl $0x62, %esi
leaq -0x48(%rbp), %rdx
callq 0x1e3430
jmp 0x35ef6c
leaq -0x48(%rbp), %rdi
callq 0x1bb120
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%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_finite_automaton.cpp |
5,089 | Omega_h::make_char_range_nfa(char, char, int) | FiniteAutomaton make_char_range_nfa(
char range_start, char range_end, int token) {
return FiniteAutomaton::make_range_nfa(
Omega_h::NCHARS, get_symbol(range_start), get_symbol(range_end), token);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movb %dl, %al
movb %sil, %dl
movq %rdi, %rsi
movq %rsi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movb %dl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movl %ecx, -0x10(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x1c3150
movl %eax, -0x1c(%rbp)
movsbl -0xa(%rbp), %edi
callq 0x1c3150
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl %eax, %ecx
movl -0x10(%rbp), %r8d
movl $0x62, %esi
callq 0x1ddc70
movq -0x18(%rbp), %rax
addq $0x30, %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_finite_automaton.cpp |
5,090 | Omega_h::make_char_single_nfa(char, int) | FiniteAutomaton make_char_single_nfa(char symbol_char, int token) {
return FiniteAutomaton::make_range_nfa(
Omega_h::NCHARS, get_symbol(symbol_char), get_symbol(symbol_char), token);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x1c3150
movl %eax, -0x1c(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x1c3150
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl %eax, %ecx
movl -0x10(%rbp), %r8d
movl $0x62, %esi
callq 0x1ddc70
movq -0x18(%rbp), %rax
addq $0x30, %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_finite_automaton.cpp |
5,091 | Omega_h::negate_set(std::set<char, std::less<char>, std::allocator<char>> const&) | std::set<char> negate_set(std::set<char> const& s) {
std::set<char> out;
for (int symbol = 0; symbol < NCHARS; ++symbol) {
auto c = inv_chartab[symbol];
if (!s.count(c)) out.insert(c);
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1cf7b0
movl $0x0, -0x18(%rbp)
cmpl $0x62, -0x18(%rbp)
jge 0x35f0f9
movslq -0x18(%rbp), %rcx
movq 0x398ed4(%rip), %rax # 0x6f7f60
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x1ba070
movq %rax, -0x58(%rbp)
jmp 0x35f0a5
movq -0x58(%rbp), %rax
cmpq $0x0, %rax
jne 0x35f0ec
movq -0x50(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x1c1a30
movb %dl, -0x61(%rbp)
movq %rax, -0x60(%rbp)
jmp 0x35f0c5
movb -0x61(%rbp), %al
movq -0x60(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movb %al, -0x38(%rbp)
jmp 0x35f0ec
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1e1e80
jmp 0x35f116
jmp 0x35f0ee
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x35f07b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x35f10c
movq -0x50(%rbp), %rdi
callq 0x1e1e80
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%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_finite_automaton.cpp |
5,092 | Omega_h::operator<<(std::ostream&, Omega_h::FiniteAutomaton const&) | std::ostream& operator<<(std::ostream& os, FiniteAutomaton const& fa) {
if (get_determinism(fa))
os << "dfa ";
else
os << "nfa ";
os << get_nstates(fa) << " states " << get_nsymbols(fa) << " symbols\n";
for (int state = 0; state < get_nstates(fa); ++state) {
for (int symbol = 0; symbol < get_nsymbols(fa); ++symbol) {
auto next_state = step(fa, state, symbol);
if (next_state != -1)
os << "(" << state << ", " << symbol << ") -> " << next_state << '\n';
}
if (!get_determinism(fa)) {
for (int symbol = get_epsilon0(fa); symbol <= get_epsilon1(fa);
++symbol) {
auto next_state = step(fa, state, symbol);
if (next_state != -1)
os << "(" << state << ", eps" << (symbol - get_epsilon0(fa))
<< ") -> " << next_state << '\n';
}
}
auto token = accepts(fa, state);
if (token != -1) os << state << " accepts " << token << '\n';
}
return os;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d2d60
testb $0x1, %al
jne 0x35f13f
jmp 0x35f151
movq -0x8(%rbp), %rdi
leaq 0x2d1f06(%rip), %rsi # 0x631050
callq 0x1cd8f0
jmp 0x35f161
movq -0x8(%rbp), %rdi
leaq 0x2d1ef9(%rip), %rsi # 0x631055
callq 0x1cd8f0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x2d1ed3(%rip), %rsi # 0x63105a
callq 0x1cd8f0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd200
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x2d1eb5(%rip), %rsi # 0x631063
callq 0x1cd8f0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc9b0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x35f3aa
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd200
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jge 0x35f27d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x1d6260
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x35f26d
movq -0x8(%rbp), %rdi
leaq 0x2d5b29(%rip), %rsi # 0x634d45
callq 0x1cd8f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x2d2e8a(%rip), %rsi # 0x6320c0
callq 0x1cd8f0
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x2d1e1d(%rip), %rsi # 0x63106d
callq 0x1cd8f0
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
movl $0xa, %esi
callq 0x1d19c0
jmp 0x35f26f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x35f1dd
movq -0x10(%rbp), %rdi
callq 0x1d2d60
testb $0x1, %al
jne 0x35f352
movq -0x10(%rbp), %rdi
callq 0x1c09d0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bb600
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jg 0x35f350
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x1d6260
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0x35f340
movq -0x8(%rbp), %rdi
leaq 0x2d5a6c(%rip), %rsi # 0x634d45
callq 0x1cd8f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x2d1d80(%rip), %rsi # 0x631073
callq 0x1cd8f0
movq %rax, -0x50(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c09d0
movl -0x54(%rbp), %esi
movq -0x50(%rbp), %rdi
subl %eax, %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x2d1d4a(%rip), %rsi # 0x63106d
callq 0x1cd8f0
movq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
movl $0xa, %esi
callq 0x1d19c0
jmp 0x35f342
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x35f29a
jmp 0x35f352
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1c7120
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
je 0x35f39a
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x2d1cfc(%rip), %rsi # 0x631079
callq 0x1cd8f0
movq %rax, %rdi
movl -0x28(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
movl $0xa, %esi
callq 0x1d19c0
jmp 0x35f39c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x35f1ba
movq -0x8(%rbp), %rax
addq $0x60, %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_finite_automaton.cpp |
5,093 | Omega_h::Table<int>::Table(int, int) | Table(int ncols_init, int nrows_reserve) : ncols(ncols_init) {
OMEGA_H_CHECK(0 <= ncols_init);
reserve(data, ncols * nrows_reserve);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1d91a0
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x35f3f2
jmp 0x35f42c
leaq 0x2cbc6f(%rip), %rdi # 0x62b068
leaq 0x2d1c83(%rip), %rsi # 0x631083
leaq 0x2d1c8c(%rip), %rdx # 0x631093
xorl %eax, %eax
movl $0x11, %ecx
callq 0x1ce550
jmp 0x35f415
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1c8350
jmp 0x35f446
movq -0x28(%rbp), %rdi
movl 0x18(%rdi), %esi
movl -0x10(%rbp), %eax
imull %eax, %esi
callq 0x1c1480
jmp 0x35f440
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%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_table.hpp |
5,094 | int Omega_h::get_nrows<int>(Omega_h::Table<int> const&) | int get_nrows(Table<T> const& t) {
OMEGA_H_CHECK(t.ncols > 0);
OMEGA_H_CHECK(size(t.data) % t.ncols == 0);
return size(t.data) / t.ncols;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jle 0x35f468
jmp 0x35f489
leaq 0x2cbbf9(%rip), %rdi # 0x62b068
leaq 0x2d1c7d(%rip), %rsi # 0x6310f3
leaq 0x2d1c16(%rip), %rdx # 0x631093
movl $0x18, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
callq 0x1cf2d0
movq -0x8(%rbp), %rcx
cltd
idivl 0x18(%rcx)
cmpl $0x0, %edx
jne 0x35f4a1
jmp 0x35f4c2
leaq 0x2cbbc0(%rip), %rdi # 0x62b068
leaq 0x2d1c50(%rip), %rsi # 0x6310ff
leaq 0x2d1bdd(%rip), %rdx # 0x631093
movl $0x19, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
callq 0x1cf2d0
movq -0x8(%rbp), %rcx
cltd
idivl 0x18(%rcx)
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_table.hpp |
5,095 | int Omega_h::get_ncols<int>(Omega_h::Table<int> const&) | int get_ncols(Table<T> const& t) {
return t.ncols;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
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 | gahansen[P]omega_h/src/Omega_h_table.hpp |
5,096 | void Omega_h::resize<int>(Omega_h::Table<int>&, int, int) | void resize(Table<T>& t, int new_nrows, int new_ncols) {
OMEGA_H_CHECK(new_ncols == t.ncols); // pretty specialized right now
Omega_h::resize(t.data, new_nrows * t.ncols);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x35f520
jmp 0x35f541
leaq 0x2cbb41(%rip), %rdi # 0x62b068
leaq 0x2d1bed(%rip), %rsi # 0x63111b
leaq 0x2d1b5e(%rip), %rdx # 0x631093
movl $0x24, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
imull 0x18(%rax), %esi
callq 0x1c0810
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_table.hpp |
5,097 | Omega_h::Table<int>::Ref Omega_h::at<int>(Omega_h::Table<int>&, int, int) | typename Table<T>::Ref at(Table<T>& t, int row, int col) {
OMEGA_H_CHECK(0 <= col);
OMEGA_H_CHECK(col < t.ncols);
OMEGA_H_CHECK(0 <= row);
OMEGA_H_CHECK(row < get_nrows(t));
return Omega_h::at(t.data, row * t.ncols + col);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorl %eax, %eax
cmpl -0x10(%rbp), %eax
jg 0x35f57b
jmp 0x35f59c
leaq 0x2cbae6(%rip), %rdi # 0x62b068
leaq 0x2d1ba7(%rip), %rsi # 0x631130
leaq 0x2d1b03(%rip), %rdx # 0x631093
movl $0x2a, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x35f5aa
jmp 0x35f5cb
leaq 0x2cbab7(%rip), %rdi # 0x62b068
leaq 0x2d1b81(%rip), %rsi # 0x631139
leaq 0x2d1ad4(%rip), %rdx # 0x631093
movl $0x2b, %ecx
movb $0x0, %al
callq 0x1ce550
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x35f5d4
jmp 0x35f5f5
leaq 0x2cba8d(%rip), %rdi # 0x62b068
leaq 0x2d1b65(%rip), %rsi # 0x631147
leaq 0x2d1aaa(%rip), %rdx # 0x631093
movl $0x2c, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c2250
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jge 0x35f60f
jmp 0x35f630
leaq 0x2cba52(%rip), %rdi # 0x62b068
leaq 0x2d1b33(%rip), %rsi # 0x631150
leaq 0x2d1a6f(%rip), %rdx # 0x631093
movl $0x2d, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
imull 0x18(%rax), %esi
addl -0x10(%rbp), %esi
callq 0x1dc3d0
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_table.hpp |
5,098 | Omega_h::Table<int>::ConstRef Omega_h::at<int>(Omega_h::Table<int> const&, int, int) | typename Table<T>::ConstRef at(Table<T> const& t, int row, int col) {
OMEGA_H_CHECK(0 <= col);
OMEGA_H_CHECK(col < t.ncols);
OMEGA_H_CHECK(0 <= row);
OMEGA_H_CHECK(row < get_nrows(t));
return Omega_h::at(t.data, row * t.ncols + col);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorl %eax, %eax
cmpl -0x10(%rbp), %eax
jg 0x35f66b
jmp 0x35f68c
leaq 0x2cb9f6(%rip), %rdi # 0x62b068
leaq 0x2d1ab7(%rip), %rsi # 0x631130
leaq 0x2d1a13(%rip), %rdx # 0x631093
movl $0x33, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x35f69a
jmp 0x35f6bb
leaq 0x2cb9c7(%rip), %rdi # 0x62b068
leaq 0x2d1a91(%rip), %rsi # 0x631139
leaq 0x2d19e4(%rip), %rdx # 0x631093
movl $0x34, %ecx
movb $0x0, %al
callq 0x1ce550
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x35f6c4
jmp 0x35f6e5
leaq 0x2cb99d(%rip), %rdi # 0x62b068
leaq 0x2d1a75(%rip), %rsi # 0x631147
leaq 0x2d19ba(%rip), %rdx # 0x631093
movl $0x35, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c2250
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jge 0x35f6ff
jmp 0x35f720
leaq 0x2cb962(%rip), %rdi # 0x62b068
leaq 0x2d1a43(%rip), %rsi # 0x631150
leaq 0x2d197f(%rip), %rdx # 0x631093
movl $0x36, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
imull 0x18(%rax), %esi
addl -0x10(%rbp), %esi
callq 0x1c57d0
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_table.hpp |
5,099 | std::map<std::set<int, std::less<int>, std::allocator<int>>*, int, Omega_h::StateSetPtrLess, std::allocator<std::pair<std::set<int, std::less<int>, std::allocator<int>>* const, int>>>::map() | map() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dc870
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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.