name string | code string | asm string | file string |
|---|---|---|---|
robin_hood::detail::Table<true, 80ul, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, robin_hood::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>... | bool try_increase_info() {
ROBIN_HOOD_LOG("mInfoInc=" << mInfoInc << ", numElements=" << mNumElements
<< ", maxNumElementsAllowed="
<< calcMaxNumElementsAllowed(mMask + 1))
if (mInfoInc <= 2) {
// need to be > 2 so that sh... | movl 0x30(%rdi), %eax
cmpl $0x3, %eax
jb 0x11779
movl $0x801, %ecx # imm = 0x801
movabsq $0x28f5c28f5c28f5c, %rsi # imm = 0x28F5C28F5C28F5C
bextrl %ecx, %eax, %ecx
movl %ecx, 0x30(%rdi)
incl 0x34(%rdi)
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
movq 0x20(%rdi), %r8
incq %r8
movq %r8, %rdx
c... | /MW55[P]DNA-Aeon/cpp/single_include/robin_hood.h |
FreqTable::FreqTable(robin_hood::detail::Table<false, 80ul, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<c... | FreqTable::FreqTable(string2stringVec& motif, string seq,
int start, bool normalized, int codewordLen,
robin_hood::unordered_map<string, char2double>& pDict):
ProbabilityEval(seq, motif, start, normalized,
codewordLen, &... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq 0x30(%rsp), %rcx
movq %rsi, %rax
movq %rdx, %rsi
movl %r9d, %ebx
movq %rdi, %r14
movq %rax, %rdx
movq %rcx, (%rsp)
movl %ebp, %ecx
callq 0xb42c
vxorps %xmm0, %xmm0, %xmm0
movw $0x0, 0xd0(%r14)
vmovups %xmm0, 0xd8(%r14)
vmovups %xmm0, 0xe4(%r14)
movl... | /MW55[P]DNA-Aeon/cpp/src/FreqTable.cpp |
FreqTable::setTotal(double) | void FreqTable::setTotal(double csum=0.0) {
(static_cast<bool>(csum) ? this -> total = csum : this -> total = accumulate(frequencies.begin(), frequencies.end(), 0.0));
} | vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jne 0x11d71
movq 0xf8(%rdi), %rax
movq 0x100(%rdi), %rcx
cmpq %rcx, %rax
je 0x11d7f
vpmovsxbq 0x4c33d(%rip), %zmm2 # 0x5e038
subq %rax, %rcx
vxorpd %xmm3, %xmm3, %xmm3
xorl %edx, %edx
addq $-0x8, %rcx
vpbroadcastq %rcx, %zmm0
shrq $0x3, %rcx
addq $0x8, %rcx
vpsrlq $0x3, ... | /MW55[P]DNA-Aeon/cpp/src/FreqTable.cpp |
FreqTable::initCum() | void FreqTable::initCum() {
vector<double> cumul;
cumul.reserve(257);
double sum = 0;
cumul.push_back(0);
for (const auto &freq : frequencies) {
sum += freq;
cumul.push_back(sum);
}
cumulative = cumul;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
vxorpd %xmm0, %xmm0, %xmm0
movq %rdi, %rbx
movq %rsp, %rdi
movq $0x0, 0x10(%rdi)
vmovapd %xmm0, (%rdi)
movl $0x101, %esi # imm = 0x101
callq 0x124b2
movq 0x8(%rsp), %rsi
xorl %eax, %eax
movq %rax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
cmpq 0x... | /MW55[P]DNA-Aeon/cpp/src/FreqTable.cpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::input_stream_adap... | token_type scan_string()
{
// reset token_buffer (ignore opening quote)
reset();
// we entered the function by reading an open quote
JSON_ASSERT(current == '\"');
while (true)
{
// get next character
switch (get())
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x254d0
cmpl $0x22, 0x14(%rbx)
jne 0x24f9d
leaq 0x50(%rbx), %r14
leaq 0x3c5db(%rip), %r12 # 0x61168
leaq 0x3a8ec(%rip), %r13 # 0x5f480
movq %rbx, %rdi
callq 0x8bd0
incl %eax
cmpl $0xf5, %eax
ja 0x24f6c
movsl... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::input_stream_adap... | int get_codepoint()
{
// this function only makes sense after reading `\u`
JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
for (const auto factor : factors)
{
get();
if (current >= '0' && current <= '... | pushq %rbx
subq $0x10, %rsp
cmpl $0x75, 0x14(%rdi)
jne 0x25532
leaq 0xc(%rsp), %rbx
leaq 0x14(%rdi), %rsi
movq %rbx, %rdx
callq 0x8d96
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x3c53d(%rip), %rdi # 0x61a76
leaq 0x3afc0(%rip), %rsi # 0x60500
leaq 0x3c53e(%rip), %rcx # 0x61a85
movl $0x1a2a, %edx... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
bool nlohmann::detail::parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::input_strea... | bool sax_parse_internal(SAX* sax)
{
// stack to remember the hierarchy of structured values we are parsing
// true = array; false = object
std::vector<bool> states;
// value to avoid a goto (see comment where set to true)
bool skip_to_state_evaluation = false;
while ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
leaq 0xb8(%rsp), %rdx
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorl %eax, %eax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rdi), %r15
leaq 0x3a1bc(%rip), %r13 # 0x5f878
movq %rax, (%rdx)
movl %eax, 0x8(%rdx)
movq ... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::end_object(... | bool end_object()
{
if (ref_stack.back())
{
if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
{
// discard object
*ref_stack.back() = discarded;
}
else
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq 0x10(%rdi), %rax
movq %rdi, %rbx
movq -0x8(%rax), %rcx
testq %rcx, %rcx
je 0x2819c
subq 0x8(%rbx), %rax
movb $0x1, 0x8(%rsp)
shrq $0x3, %rax
decl %eax
movl %eax, 0x28(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x28350
leaq 0x80(%rbx), %rdi
leaq... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::end_array() | bool end_array()
{
bool keep = true;
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
if (keep)
{
ref_stack.back()->set_parents();
}
else
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x10(%rdi), %rax
movb $0x1, %bpl
movq %rdi, %rbx
movq -0x8(%rax), %rcx
testq %rcx, %rcx
je 0x286b3
subq 0x8(%rbx), %rax
movb $0x3, 0xb(%rsp)
shrq $0x3, %rax
decl %eax
movl %eax, 0xc(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x2876f
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
l... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::basic_json(nlohmann::basic_json<std::map, std::vector, std:... | basic_json(const basic_json& other)
: m_type(other.m_type)
{
// check of passed value is valid
other.assert_invariant();
switch (m_type)
{
case value_t::object:
{
m_value = *other.m_value.object;
break;
}
... | pushq %r14
pushq %rbx
pushq %rax
movb (%rsi), %al
movq %rsi, %r14
movq %rdi, %rbx
movb %al, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rsi, %rdi
movl $0x1, %esi
callq 0x230b6
movzbl (%rbx), %eax
decl %eax
cmpl $0x7, %eax
ja 0x28fd8
leaq 0x36954(%rip), %rcx # 0x5f8e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
void nlohmann::detail::external_constructor<(nlohmann::detail::value_t)4>::construct<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::al... | static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
{
j.m_value.destroy(j.m_type);
j.m_type = value_t::boolean;
j.m_value = b;
j.assert_invariant();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %ebp
movzbl (%rbx), %esi
addq $0x8, %rdi
callq 0x2318c
movzbl %bpl, %eax
movb $0x4, (%rbx)
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x230b6
movq %rax, %rdi
callq 0xde65
| /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
std::pair<bool, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>*> nlohmann::detail::json_sax_dom_callback_pa... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
movl %edx, %ebp
movq %rdi, %rbx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x2ad6e
movl %ecx, %ecx
leaq -0x1(%rcx), %rdx
movabsq $-0x8000000000000000, %r15 # imm = 0x... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>* nlohmann::detail::json_sax_dom_parser<nlohmann::basic_json<... | JSON_HEDLEY_RETURNS_NON_NULL
BasicJsonType* handle_value(Value&& v)
{
if (ref_stack.empty())
{
root = BasicJsonType(std::forward<Value>(v));
return &root;
}
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
if (ref_stack... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rax
movq %rdi, %rbx
cmpq %rax, 0x8(%rdi)
je 0x2c177
movq -0x8(%rax), %rax
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x2c1ba
cmpl $0x2, %ecx
jne 0x2c20c
movq 0x8(%rax), %rdi
callq 0x2c24a
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax)... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>* nlohmann::detail::json_sax_dom_parser<nlohmann::basic_json<... | JSON_HEDLEY_RETURNS_NON_NULL
BasicJsonType* handle_value(Value&& v)
{
if (ref_stack.empty())
{
root = BasicJsonType(std::forward<Value>(v));
return &root;
}
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
if (ref_stack... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rax
movq %rdi, %rbx
cmpq %rax, 0x8(%rdi)
je 0x2c657
movq -0x8(%rax), %rax
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x2c695
cmpl $0x2, %ecx
jne 0x2c6e2
movq 0x8(%rax), %rdi
callq 0x2c720
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax)... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
nlohmann::detail::iteration_proxy_value<nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned ... | explicit iteration_proxy_value(IteratorType it) noexcept
: anchor(std::move(it))
{} | pushq %rbx
vmovups (%rsi), %ymm0
movq %rdi, %rbx
leaq 0x40(%rbx), %rax
vmovups %ymm0, (%rdi)
vxorps %xmm0, %xmm0, %xmm0
addq $0x30, %rdi
vmovups %xmm0, 0x20(%rbx)
movq %rax, 0x30(%rbx)
leaq 0x3da7e(%rip), %rsi # 0x6a7c8
leaq 0x3da78(%rip), %rdx # 0x6a7c9
vzeroupper
callq 0xe5e4
leaq 0x60(%rbx), %rax
movq %rax, ... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
Inflate::readCB() | int Inflate::readCB() {
int temp = bitin.read();
if (temp == -1) {
(nBits == 16 ? temp = 1 : temp = 0);
nBits--;
if (nBits == -1) {
readingDone = true;
}
}
return temp;
} | pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0x129fe
cmpl $-0x1, %eax
jne 0x2d3a5
movl 0x50(%rbx), %ecx
xorl %eax, %eax
cmpl $0x10, %ecx
sete %al
subl $0x1, %ecx
movl %ecx, 0x50(%rbx)
jae 0x2d3a5
movb $0x1, 0x60(%rbx)
popq %rbx
retq
nop
| /MW55[P]DNA-Aeon/cpp/src/ACEncode.cpp |
absl::container_internal::btree_node<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::init_leaf(int, absl::container_internal::btree_node<absl::container_internal::set_params... | CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
using C = typename std::remove_const<Char>::type;
static_assert(
std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
std::is_same<C, signed char>(),
"The argument must be a pointer to [const] [signed|unsigned] char"... | testb $0x7, %dil
jne 0x33870
movq %rdx, (%rdi)
movw $0x0, 0x8(%rdi)
movb $0x0, 0xa(%rdi)
movb %sil, 0xb(%rdi)
jmp 0x3390a
pushq %rax
leaq 0x30b59(%rip), %rdi # 0x643d1
leaq 0x30b82(%rip), %rsi # 0x64401
leaq 0x32a5f(%rip), %rcx # 0x662e5
movl $0x1e3, %edx # imm = 0x1E3
callq 0x8330
| /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/layout.h |
void* absl::container_internal::Allocate<8ul, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>>(std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>*, unsigned long) | void* Allocate(Alloc* alloc, size_t n) {
static_assert(Alignment > 0, "");
assert(n && "n must be positive");
using M = AlignedType<Alignment>;
using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
// On macO... | pushq %rax
testq %rsi, %rsi
je 0x338b0
addq $0x7, %rsi
leaq 0x7(%rsp), %rdi
xorl %edx, %edx
shrq $0x3, %rsi
callq 0x338ee
testb $0x7, %al
jne 0x338cf
popq %rcx
retq
leaq 0x317f6(%rip), %rdi # 0x650ad
leaq 0x31809(%rip), %rsi # 0x650c7
leaq 0x32947(%rip), %rcx # 0x6620c
movl $0x38, %edx
callq 0x8330
leaq 0x3... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/container_memory.h |
absl::container_internal::btree_node<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::start_slot() | slot_type *start_slot() { return slot(start()); } | pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x314e6
vmovaps 0x30600(%rip), %ymm0 # 0x63f20
movq %rsp, %rdi
movq %rbx, %rsi
movl %eax, %ebp
vmovups %ymm0, (%rdi)
movq $0x1f, 0x20(%rdi)
vzeroupper
callq 0x3162a
movzbl %bpl, %ecx
leaq (%rax,%rcx,8), %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
| /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/btree.h |
absl::container_internal::SearchResult<int, false> absl::container_internal::btree_node<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::binary_search_impl<std::unique_ptr<Se... | SearchResult<int, false> binary_search_impl(
const K &k, int s, int e, const Compare &comp,
std::false_type /* IsCompareTo */) const {
while (s != e) {
const int mid = (s + e) >> 1;
if (comp(key(mid), k)) {
s = mid + 1;
} else {
e = mid;
}
}
return SearchR... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r12d
cmpl %ecx, %edx
jne 0x339ba
movl %r12d, %ebx
jmp 0x33a11
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r13
vmovaps 0x30553(%rip), %ymm0 # 0x63f20
leal (%r12,%rbx), %ebp
movq %r13, %rdi
movq %r15, %rsi
sa... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/btree.h |
std::conditional<std::is_const<char const>::value, std::tuple_element<3ul, std::tuple<absl::container_internal::btree_node<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>*, u... | CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
using C = typename std::remove_const<Char>::type;
static_assert(
std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
std::is_same<C, signed char>(),
"The argument must be a pointer to [const] [signed|unsigned] char"... | testb $0x7, %sil
jne 0x33a4b
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
shlq $0x3, %rax
leaq (%rax,%rcx,4), %rax
leaq 0x7(%rdx,%rax), %rax
andq $-0x8, %rax
addq %rax, %rsi
movq %rsi, %rax
retq
pushq %rax
leaq 0x3097e(%rip), %rdi # 0x643d1
leaq 0x309a7(%rip), %rsi # 0x64401
leaq 0x331f0(%rip), ... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/layout.h |
absl::container_internal::btree_node<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::transfer_n(unsigned long, unsigned long, unsigned long, absl::container_internal::btree_... | void transfer_n(const size_type n, const size_type dest_i,
const size_type src_i, btree_node *src_node,
allocator_type *alloc) {
next_generation();
for (slot_type *src = src_node->slot(src_i), *end = src + n,
*dest = slot(dest_i);
src != end; ++src... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
vmovaps 0x3049e(%rip), %ymm0 # 0x63f20
leaq 0x10(%rsp), %rbp
movl $0x1f, %r14d
movq %rsi, %rbx
movq %rdi, %r13
movq %rcx, %r15
movq %rdx, 0x8(%rsp)
movq %r8, %rsi
movq %rbp, %rdi
vmovups %ymm0, (%rbp)
movq %r14, 0x20(%rbp)
vzeroupper
... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/btree.h |
absl::container_internal::btree<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::rebalance_or_split(absl::container_internal::btree_iterator<absl::container_internal::btree_n... | void btree<P>::rebalance_or_split(iterator *iter) {
node_type *&node = iter->node_;
int &insert_position = iter->position_;
assert(node->count() == node->max_count());
assert(kNodeSlots == node->max_count());
// First try to make room on the node by rebalancing.
node_type *parent = node->parent();
if (no... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq (%rsi), %rdi
movq %rsi, %rbx
callq 0x31536
movq (%rbx), %rcx
testb $0x7, %cl
jne 0x33fa8
movzbl 0xb(%rcx), %edx
movl $0x1e, %esi
testb %dl, %dl
cmovnel %edx, %esi
cmpb %sil, %al
jne 0x33fc7
cmpb $0x1e, %al
jne 0x33fe... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/btree.h |
void absl::container_internal::btree_node<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::emplace_value<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>(unsigned lo... | inline void btree_node<P>::emplace_value(const size_type i,
allocator_type *alloc,
Args &&... args) {
assert(i >= start());
assert(i <= finish());
// Shift old values to create space for new value and then construct it in
// place... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x314e6
movzbl %al, %eax
cmpq %rbx, %rax
ja 0x341b1
testb $0x7, %r14b
jne 0x341d0
movzbl 0xa(%r14), %esi
subq %rbx, %rsi
jb 0x341ef
jbe 0x3412e
leaq 0x1(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rc... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/btree.h |
absl::container_internal::btree_node<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::rebalance_right_to_left(int, absl::container_internal::btree_node<absl::container_intern... | void btree_node<P>::rebalance_right_to_left(const int to_move,
btree_node *right,
allocator_type *alloc) {
assert(parent() == right->parent());
assert(position() + 1 == right->position());
assert(right->count() >= count());
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
testb $0x7, %r15b
jne 0x3440f
movq %rdx, %rbx
testb $0x7, %bl
jne 0x3440f
movq (%r15), %rax
cmpq (%rbx), %rax
jne 0x3442e
movzbl 0x8(%r15), %eax
movq %rcx, %r12
movzbl 0x8(%rbx), %ecx
incl %eax
cmpl %ecx, %eax
jne 0x3444d
movq ... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/btree.h |
absl::container_internal::btree_node<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::rebalance_left_to_right(int, absl::container_internal::btree_node<absl::container_intern... | void btree_node<P>::rebalance_left_to_right(const int to_move,
btree_node *right,
allocator_type *alloc) {
assert(parent() == right->parent());
assert(position() + 1 == right->position());
assert(count() >= right->count());
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
testb $0x7, %r15b
jne 0x346ac
movq %rdx, %rbx
testb $0x7, %bl
jne 0x346ac
movq (%r15), %rax
cmpq (%rbx), %rax
jne 0x346cb
movzbl 0x8(%r15), %eax
movq %rcx, %r12
movzbl 0x8(%rbx), %ecx
incl %eax
cmpl %ecx, %eax
jne 0x346ea
movq ... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/btree.h |
absl::container_internal::btree_node<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::split(int, absl::container_internal::btree_node<absl::container_internal::set_params<std... | void btree_node<P>::split(const int insert_position, btree_node *dest,
allocator_type *alloc) {
assert(dest->count() == 0);
assert(max_count() == kNodeSlots);
// We bias the split based on the position being inserted. If we're
// inserting at the beginning of the left node then bias t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rdx, %rdi
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %r12d
callq 0x31536
testb %al, %al
jne 0x3498e
testb $0x7, %r14b
jne 0x34977
movzbl 0xb(%r14), %eax
testl %eax, %eax
je 0x347e7
cmpl $0x1e, %eax
jne 0x349eb
movq %r14, ... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/btree.h |
absl::container_internal::btree_node<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::make_root() | void make_root() {
assert(parent()->is_root());
set_generation(parent()->generation());
set_parent(parent()->parent());
} | pushq %rbx
movq %rdi, %rbx
testb $0x7, %bl
jne 0x358ba
movq (%rbx), %rdi
callq 0x318bc
testb %al, %al
je 0x358d9
movq (%rbx), %rax
testb $0x7, %al
jne 0x358ba
movq (%rax), %rax
movq %rax, (%rbx)
popq %rbx
retq
leaq 0x2eb10(%rip), %rdi # 0x643d1
leaq 0x2eb39(%rip), %rsi # 0x64401
leaq 0x2f8f8(%rip), %rcx # 0... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/btree.h |
absl::container_internal::btree_node<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::merge(absl::container_internal::btree_node<absl::container_internal::set_params<std::uni... | void btree_node<P>::merge(btree_node *src, allocator_type *alloc) {
assert(parent() == src->parent());
assert(position() + 1 == src->position());
// Move the delimiting value to the left node.
value_init(finish(), alloc, parent()->slot(position()));
// Move the values from the right to the left node.
tran... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
testb $0x7, %r14b
jne 0x35a6a
movq %rsi, %r15
testb $0x7, %r15b
jne 0x35a6a
movq (%r14), %rsi
cmpq (%r15), %rsi
jne 0x35a89
movzbl 0x8(%r14), %r13d
movzbl 0x8(%r15), %ecx
leal 0x1(%r13), %eax
cmpl %ecx, %eax
jne 0x35aa8
v... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/btree.h |
absl::container_internal::btree_node<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::remove_values(unsigned char, unsigned char, std::allocator<std::unique_ptr<SeqEntry, std... | inline void btree_node<P>::remove_values(const field_type i,
const field_type to_erase,
allocator_type *alloc) {
// Transfer values after the removed range into their new places.
value_destroy_n(i, to_erase, alloc);
const field_type... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x31450
testb $0x7, %r14b
jne 0x35ba3
movzbl 0xa(%r14), %r13d
movzbl %bpl, %r15d
movl %ebx, 0xc(%rsp)
movzbl %bl, %ebx
movq %r14, %rdi
movq %r14, %r8
movq %r12, %r9
le... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/btree.h |
absl::container_internal::btree<absl::container_internal::set_params<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>, compare_ptr, std::allocator<std::unique_ptr<SeqEntry, std::default_delete<SeqEntry>>>, 256, true>>::erase_range(absl::container_internal::btree_iterator<absl::container_internal::btree_node<abs... | auto btree<P>::erase_range(iterator begin, iterator end)
-> std::pair<size_type, iterator> {
difference_type count = std::distance(begin, end);
assert(count >= 0);
if (count == 0) {
return {0, begin};
}
if (static_cast<size_type>(count) == size_) {
clear();
return {count, this->end()};
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpq %r8, %rdx
movq %rdx, 0x10(%rsp)
movl %ecx, %ebp
movl %ecx, 0x18(%rsp)
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, 0x28(%rsp)
setne %al
cmpl %ecx, %r9d
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x35c67
leaq 0x10(%rsp), %rbx
movl ... | /MW55[P]DNA-Aeon/abseil-cpp/absl/container/internal/btree.h |
void nlohmann::detail::get_arithmetic_value<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, unsigned long, ... | void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
{
switch (static_cast<value_t>(j))
{
case value_t::number_unsigned:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
break;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movzbl (%rdi), %eax
movq %rdi, %r14
cmpl $0x5, %eax
je 0x35dd3
cmpl $0x7, %eax
je 0x35dd9
cmpl $0x6, %eax
jne 0x35df0
movq 0x8(%r14), %rax
jmp 0x35de0
vcvttsd2usi 0x8(%r14), %rax
movq %rax, (%rsi)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
parseFasta(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | robin_hood::unordered_set<std::string> parseFasta(const std::string &fileName) {
/*
* Parses a fasta file and returns a set of all sequences.
*/
robin_hood::unordered_set<std::string> sequences = robin_hood::unordered_set<std::string>();
std::ifstream input(fileName);
if (!input.good()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movabsq $-0x3b314601e57a13ad, %rax # imm = 0xC4CEB9FE1A85EC53
leaq 0x20(%rdi), %rcx
vxorps %xmm0, %xmm0, %xmm0
movq %rsi, %r12
movq %rdi, %rbx
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
vmovups... | /MW55[P]DNA-Aeon/cpp/include/FastaParser.h |
encode_zip(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, FreqTable const&, unsigned short, bool, std::__c... | void
encode_zip(nlohmann::json config, const FreqTable &freqs, uint16_t minLen, bool sameLength, string configPath) {
int maxLen = 0;
Zippy::ZipArchive inarch(config["encode"]["input"]);
std::vector<std::string> ents = inarch.GetEntryNames();
absl::synchronization_internal::ThreadPool pool(static_cast<i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %r8, %r13
movl %ecx, %ebp
movq %rsi, 0x28(%rsp)
movw %dx, 0xa(%rsp)
leaq 0x3319c(%rip), %rsi # 0x696e1
movq %rdi, (%rsp)
callq 0x19204
leaq 0x2c604(%rip), %rsi # 0x62b59
movq %rax, %rdi
callq 0x1920... | /MW55[P]DNA-Aeon/cpp/src/main.cpp |
parseValidateConfig(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) | nlohmann::json parseValidateConfig(string configPath, bool encode) {
ifstream cf(configPath);
nlohmann::json config = nlohmann::json::parse(cf, nullptr, true, true);
try {
//sync required
static_cast<void>(config.at(nlohmann::json::json_pointer("/general/sync")));
//as_fasta def... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movl %edx, %ebp
leaq 0x230(%rsp), %r14
movl $0x8, %edx
movq %rdi, %rbx
movq %r14, %rdi
callq 0x8870
leaq 0x210(%rsp), %rdx
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rdx)
movl $0x1, %ecx
movl $0x1, %r8d
movq %r... | /MW55[P]DNA-Aeon/cpp/src/main.cpp |
main | int main(int argc, char *argv[]) {
res_lock = new std::mutex();
argparse::ArgumentParser program("arithmetic_error_correction", "1.0.0");
program.add_argument("-e", "--encode").default_value(false).implicit_value(true).help("encode a file");
program.add_argument("-d", "--decode").default_value(false).im... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp # imm = 0x1028
movl %edi, %ebp
movl $0x28, %edi
movq %rsi, %rbx
callq 0x8530
leaq 0x1a8(%rsp), %r14
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x20(%rax)
movq %rax, 0x516bf(%rip) # 0x8a770
vmovups %ymm0, (%rax)
movq %r14, -0x1... | /MW55[P]DNA-Aeon/cpp/src/main.cpp |
mz_zip_file_read_func(void*, unsigned long, void*, unsigned long) | static size_t mz_zip_file_read_func(void* pOpaque, mz_uint64 file_ofs, void* pBuf, size_t n) {
mz_zip_archive* pZip = (mz_zip_archive*)pOpaque;
mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
file_ofs += pZip->m_pState->m_file_archive_start_ofs;
if (((mz_int64)file_ofs < 0) || (((cur_ofs != (... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x68(%rdi), %rax
movq %rdi, %r15
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq 0x70(%rax), %rdi
callq 0x87f0
movq 0x68(%r15), %rcx
addq 0x78(%rcx), %r12
js 0x3b2f0
cmpq %r12, %rax
je 0x3b302
movq 0x70(%rcx), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x... | /MW55[P]DNA-Aeon/cpp/src/../../Zippy/library/Zippy/miniz/miniz.h |
mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive*) | static void mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive* pZip) {
mz_zip_internal_state* pState = pZip->m_pState;
const mz_zip_array* pCentral_dir_offsets = &pState->m_central_dir_offsets;
const mz_zip_array* pCentral_dir = &pState->m_central_dir;
mz_uint32* pIndices;
mz_uint32... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x2, %edi
jb 0x3b7cf
cmpq $0x0, 0x48(%rsi)
movq %rsi, %r9
je 0x3b7de
movq 0x40(%r9), %rax
leal -0x2(%rdi), %ecx
movq %rdi, 0x18(%rsp)
movl %edi, %r10d
movq %r9, 0x28(%rsp)
shrl %ecx
movq %rax, 0x30(%rsp)
leaq 0x1(%rcx,%rcx), %rbx
m... | /MW55[P]DNA-Aeon/cpp/src/../../Zippy/library/Zippy/miniz/miniz.h |
mz_zip_array_ensure_capacity(mz_zip_archive*, mz_zip_array*, unsigned long, unsigned int) | static mz_bool
mz_zip_array_ensure_capacity(mz_zip_archive* pZip, mz_zip_array* pArray, size_t min_new_capacity, mz_uint growing) {
void* pNew_p;
size_t new_capacity = min_new_capacity;
MZ_ASSERT(pArray->m_element_size);
if (pArray->m_capacity >= min_new_capacity)
return MZ_TRUE;
if (growin... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl 0x18(%rsi), %edx
testq %rdx, %rdx
je 0x3b843
movl $0x1, %ebx
movq %rsi, %r15
cmpq %r14, 0x10(%rsi)
jae 0x3b83b
movq %rdi, %rax
movq 0x40(%rdi), %rdi
movq (%r15), %rsi
movq %r14, %rcx
callq *0x38(%rax)
testq %rax, %rax
je 0x3b839
movq %rax, (%r15)
movq %r14, 0x10(%r1... | /MW55[P]DNA-Aeon/cpp/src/../../Zippy/library/Zippy/miniz/miniz.h |
Zippy::ZipArchive::ZipArchive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit ZipArchive(const std::string& fileName)
: m_ArchivePath(fileName) {
// ===== Open file stream
std::ifstream f(fileName.c_str());
// ===== If successful, continue to open the file.
if (f.good()) {
f.close();
Open(f... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
leaq 0x4cc0f(%rip), %rax # 0x88aa0
vxorps %xmm0, %xmm0, %xmm0
leaq 0x88(%rdi), %r12
movq %rsi, %r15
leaq 0x78(%rdi), %r14
movq %rdi, %rbx
movq %rax, (%rdi)
vmovups %zmm0, 0x8(%rdi)
vmovups %zmm0, 0x38(%rdi)
movq %r12, 0x78(%rdi)
... | /MW55[P]DNA-Aeon/cpp/src/../../Zippy/library/Zippy/ZipArchive.hpp |
absl::synchronization_internal::ThreadPool::ThreadPool(int) | explicit ThreadPool(int num_threads) {
for (int i = 0; i < num_threads; ++i) {
threads_.push_back(std::thread(&ThreadPool::WorkLoop, this));
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
vxorps %xmm0, %xmm0, %xmm0
movq %rdi, %rbx
movl %esi, %ebp
addq $0x8, %rdi
vmovups %zmm0, 0x18(%rbx)
vmovups %zmm0, (%rbx)
xorl %esi, %esi
movq %rdi, 0x8(%rsp)
vzeroupper
callq 0x3d5a8
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x68(%rbx)
vmo... | /MW55[P]DNA-Aeon/abseil-cpp/absl/synchronization/internal/thread_pool.h |
nlohmann::operator<<(std::ostream&, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const&) | friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
{
// read width member and use it as indentation parameter if nonzero
const bool pretty_print = o.width() > 0;
const auto indentation = pretty_print ? o.width() : 0;
// reset width to 0 for subsequent calls to thi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq (%rdi), %rax
movq %rdi, %rbx
movq %rsi, %r14
movq -0x18(%rax), %rax
movq 0x10(%rdi,%rax), %r13
movq $0x0, 0x10(%rdi,%rax)
movl $0x20, %edi
callq 0x8530
movabsq $0x100000001, %rdx # imm = 0x100000001
le... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
bool nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::value<bool, 0>(nlohmann::json_pointer<nlohmann::basic_... | ValueType value(const json_pointer& ptr, const ValueType& default_value) const
{
// at only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
// if pointer resolves a value, return it or use default value
JSON_TRY
{
return ptr.get_ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
cmpb $0x1, (%rdi)
movq %rdi, %r14
jne 0x3c385
movq %rsi, %rdi
movq %r14, %rsi
movq %rdx, %rbx
callq 0x469c2
leaq 0x20(%rsp), %rsi
movb $0x0, (%rsi)
movq %rax, %rdi
callq 0x43259
movb 0x20(%rsp), %bl
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocato... | ValueType value(const json_pointer& ptr, const ValueType& default_value) const
{
// at only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
// if pointer resolves a value, return it or use default value
JSON_TRY
{
return ptr.get_ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
cmpb $0x1, (%rsi)
movq %rsi, %r14
jne 0x3c4c8
movq %rdi, %rbx
movq %rcx, %r15
movq %rdx, %rdi
movq %r14, %rsi
callq 0x469c2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x22c74
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq ... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
int nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::value<int, 0>(nlohmann::json_pointer<nlohmann::basic_js... | ValueType value(const json_pointer& ptr, const ValueType& default_value) const
{
// at only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
// if pointer resolves a value, return it or use default value
JSON_TRY
{
return ptr.get_ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
cmpb $0x1, (%rdi)
movq %rdi, %r14
jne 0x3c640
movq %rsi, %rdi
movq %r14, %rsi
movq %rdx, %rbx
callq 0x469c2
leaq 0x20(%rsp), %rsi
movl $0x0, (%rsi)
movq %rax, %rdi
callq 0x326e1
movl 0x20(%rsp), %ebx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq ... | /MW55[P]DNA-Aeon/cpp/single_include/nlohmann/json.hpp |
argparse::ArgumentParser::ArgumentParser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, argparse::default_arguments) | explicit ArgumentParser(std::string aProgramName = {},
std::string aVersion = "1.0",
default_arguments aArgs = default_arguments::all)
: mProgramName(std::move(aProgramName)), mVersion(std::move(aVersion)) {
if (aArgs & default_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
addq $0x10, %rdi
movl %ecx, %ebp
leaq 0x10(%rsi), %rax
movq %rdi, (%rbx)
movq (%rsi), %rcx
cmpq %rax, %rcx
je 0x3c8db
movq %rcx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x3c8e3
vmovups (%rax), %xmm0
vmovups %xm... | /MW55[P]DNA-Aeon/cpp/single_include/argparse.hpp |
argparse::Argument& argparse::ArgumentParser::add_argument<char const*, char const*>(char const*, char const*) | Argument &add_argument(Targs... Fargs) {
using array_of_sv = std::string_view[sizeof...(Targs)];
auto tArgument = mOptionalArguments.emplace(cend(mOptionalArguments),
array_of_sv{Fargs...});
if (!tArgument->mIsOptional)
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xa0(%rdi), %r14
movq %rsi, %rdi
callq 0x81f0
movq %rsp, %r13
movq %rax, (%r13)
movq %r15, %rdi
movq %r12, 0x8(%r13)
callq 0x81f0
movq %rax, 0x10(%r13)
movq %r15, 0x18(%r13)
movq %r14, %rdi
movq ... | /MW55[P]DNA-Aeon/cpp/single_include/argparse.hpp |
argparse::ArgumentParser::parse_args(int, char const* const*) | void parse_args(int argc, const char *const argv[]) {
std::vector<std::string> arguments;
std::copy(argv, argv + argc, std::back_inserter(arguments));
parse_args(arguments);
} | pushq %rbx
subq $0x20, %rsp
vxorps %xmm0, %xmm0, %xmm0
movslq %esi, %rcx
movq %rdx, %rax
movq %rsp, %rdx
movq %rdi, %rbx
movq $0x0, 0x10(%rdx)
vmovaps %xmm0, (%rdx)
leaq (%rax,%rcx,8), %rsi
movq %rax, %rdi
callq 0x3e576
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3e61c
movq 0xd0(%rbx), %rdi
addq $0xc0, %rbx
movq %rbx, %rsi... | /MW55[P]DNA-Aeon/cpp/single_include/argparse.hpp |
argparse::operator<<(std::ostream&, argparse::ArgumentParser const&) | auto operator<<(std::ostream &stream, const ArgumentParser &parser)
-> std::ostream & {
if (auto sen = std::ostream::sentry(stream)) {
stream.setf(std::ios_base::left);
stream << "Usage: " << parser.mProgramName << " [options] ";
std::size_t tLongestAr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rsi, %r14
movq %rbx, %rsi
movq %r15, %rdi
callq 0x8450
cmpb $0x1, (%r15)
jne 0x3d09c
movq (%rbx), %rax
movq -0x18(%rax), %rax
orl $0x20, 0x18(%rbx,%rax)
leaq 0x2cbb3(%rip), %rsi # 0x69ac1
mo... | /MW55[P]DNA-Aeon/cpp/single_include/argparse.hpp |
void inflating<std::basic_ofstream<char, std::char_traits<char>>>(FreqTable&, BitInStream&, std::basic_ofstream<char, std::char_traits<char>>&, int) | void inflating(FreqTable &freqs, BitInStream &bitin, T &out, int minLen = 0) {
Inflate inf(16, bitin);
bool flag = false;
int len = 0;
while (true) {
int sym = inf.read(freqs);
if (len >= minLen - 1) {
if (inf.readingDone) {
if(bitin.streamDone && (bitin.remBi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
leaq 0x8(%rsp), %r12
movl $0x10, %esi
movq %rdx, %rbx
movq %rdi, %r15
movl %ecx, %ebp
movq %r14, %rdx
movq %r12, %rdi
callq 0x2d324
decl %ebp
xorl %r13d, %r13d
movq %r12, %rdi
movq %r15, %rsi
callq 0x2d3a8
cmpl %ebp, %r13... | /MW55[P]DNA-Aeon/cpp/src/../include/ACEncode.h |
bsplib::Spmd::Spmd(int) | Spmd :: Spmd( int nprocs )
{
int mpi_init;
int world_pid = -1;
MPI_Initialized(&mpi_init);
assert( mpi_init );
MPI_Bcast( &nprocs, 1, MPI_INT, 0, MPI_COMM_WORLD );
MPI_Comm_rank( MPI_COMM_WORLD, & world_pid );
m_closed = false;
m_active = world_pid < nprocs;
MPI_Comm_split( MP... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %esi, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp) # imm = 0xFFFFFFFF
leaq 0x14(%rsp), %r14
movq %r14, %rdi
callq 0x7160
cmpl $0x0, (%r14)
je 0xa417
movq 0x13c2c(%rip), %rdx # 0x1dfc0
movq 0x13bf5(%rip), %r14 # 0x1df90
leaq 0x10(%rsp),... | /wijnand-suijlen[P]bsponmpi/src/spmd.cc |
bsplib::Unbuf::wait() | void Unbuf :: wait( )
{
while (true)
{
int outcount = MPI_UNDEFINED;
MPI_Waitsome( int(m_reqs.size()), m_reqs.data(), &outcount,
m_ready.data(), MPI_STATUSES_IGNORE );
if (outcount == MPI_UNDEFINED )
break;
for (int i = 0; i < outcount; ++i ) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0xffff8002, %ebp # imm = 0xFFFF8002
leaq 0xc(%rsp), %r14
movl %ebp, (%r14)
movq 0x48(%rdi), %rsi
movq 0x50(%rdi), %rdi
subq %rsi, %rdi
shrq $0x3, %rdi
movq 0x60(%rbx), %rcx
movq %r14, %rdx
xorl %r8d, %r8d
callq 0x72c0
mo... | /wijnand-suijlen[P]bsponmpi/src/unbuf.cc |
bsplib::Rdma::hpget(int, unsigned long, unsigned long, void*, unsigned long) | void Rdma::hpget( int src_pid, Memslot src_slot, size_t src_offset,
void * dst, size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::HPGET );
#endif
if ( size < m_min_n_hp_msg_size ) {
get( src_pid, src_slot, src_offset, dst, size );
return;
}
assert( !( slot( m_pid, src_slot ).sta... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r15
movq %r8, 0x8(%rsp)
cmpq %r9, 0x2f8(%rdi)
jbe 0xd099
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r9
addq $0x48, %rsp
popq %rbx... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
bsplib::Rdma::ActionBuf::execute(bsplib::Rdma&) | void Rdma::ActionBuf::execute( Rdma & rdma )
{
const int pid = rdma.m_pid;
for (size_t i = 0; i < m_actions.size(); ++i )
{
Action a = m_actions[i];
#ifdef PROFILE
TicToc t( a.kind==Action::GET? TicToc::GET:
a.kind==Action::HPPUT? TicToc::HPPUT:
TicToc::H... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq (%rdi), %rax
movq %rdi, 0x30(%rsp)
cmpq %rax, 0x8(%rdi)
je 0xe027
movq 0x8(%rsp), %rdx
movslq 0x2f0(%rdx), %rcx
leaq 0x428(%rdx), %rsi
movq %rsi, 0x10(%rsp)
addq $0x178, %rdx # imm = 0x178
movq %rdx, ... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
bsplib::Rdma::ActionBuf::ActionBuf(int) | ActionBuf( int nprocs )
: m_actions()
, m_counts( nprocs )
, m_get_buffer_offset( nprocs )
{} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movslq %esi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xea76
leaq 0x30(%rbx), %rdi
leaq 0xe(%rsp), %rdx
movq %r14, %rsi
callq 0xea76
addq $0x10, %r... | /wijnand-suijlen[P]bsponmpi/src/rdma.h |
void bsplib::deserial<unsigned int>(bsplib::A2A&, int, unsigned int&) | const void * recv_top( int src_pid ) const {
std::size_t o = src_pid * m_recv_cap + m_recv_pos[src_pid];
return static_cast< const void *>( m_recv_bufs.data() + o );
} | pushq %rbp
pushq %r14
pushq %rbx
movslq %esi, %rax
movq 0x28(%rdi), %r9
imulq %rax, %r9
movq 0xd8(%rdi), %rcx
movq (%rcx,%rax,8), %rsi
addq 0xf0(%rdi), %r9
addq %rsi, %r9
movl $0x0, (%rdx)
movl $0x1, %r10d
xorl %r8d, %r8d
movabsq $0x100000000, %r11 # imm = 0x100000000
xorl %ebx, %ebx
addq %r11, %r8
movzbl (%r9), %... | /wijnand-suijlen[P]bsponmpi/src/a2a.h |
curlx_sltoui | unsigned int curlx_sltoui(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < CURL_SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_UINT);
#endif
return... | movq %rdi, %rax
retq
| /pelya[P]curl/lib/warnless.c |
curlx_sltous | unsigned short curlx_sltous(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_USHORT);
return (unsigned short)(slnum & (long) CURL_M... | movq %rdi, %rax
retq
| /pelya[P]curl/lib/warnless.c |
curlx_sztosi | int curlx_sztosi(ssize_t sznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sznum >= 0);
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT);
#endif
return (int)(sznum & (ssize_t... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /pelya[P]curl/lib/warnless.c |
curlx_uitosi | int curlx_uitosi(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_SINT);
return (int) (uinum & (unsigned int) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warni... | movl %edi, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /pelya[P]curl/lib/warnless.c |
archs_enable | static void archs_enable(void)
{
static bool initialized = false;
if (initialized)
return;
#ifdef CAPSTONE_HAS_ARM
ARM_enable();
#endif
#ifdef CAPSTONE_HAS_ARM64
AArch64_enable();
#endif
#ifdef CAPSTONE_HAS_MIPS
Mips_enable();
#endif
#ifdef CAPSTONE_HAS_POWERPC
PPC_enable();
#endif
#ifdef CAPSTONE_HAS_SPARC
... | cmpb $0x0, 0x24c544(%rip) # 0x28fc24
jne 0x43716
pushq %rax
callq 0x44d10
callq 0x44e48
callq 0x44f1c
callq 0x45014
callq 0x47650
callq 0x4772c
callq 0x450f0
callq 0x477f8
movb $0x1, 0x24c512(%rip) # 0x28fc24
addq $0x8, %rsp
retq
| /TriDis[P]capstone/cs.c |
fill_insn | static void fill_insn(struct cs_struct *handle, cs_insn *insn, char *buffer, MCInst *mci,
PostPrinter_t postprinter, const uint8_t *code)
{
#ifndef CAPSTONE_DIET
char *sp, *mnem;
#endif
uint16_t copy_size = MIN(sizeof(insn->bytes), insn->size);
// fill the instruction bytes.
// we might skip some redundant bytes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movzwl 0x10(%rsi), %esi
cmpw $0x10, %si
movl $0x10, %ebp
cmovbl %esi, %ebp
movq %rdi, %r13
leaq 0x12(%rbx), %rdi
addq %r9, %rsi
subq %rbp, %rsi
movq %rbp, %rdx
callq 0x430e0
movw %... | /TriDis[P]capstone/cs.c |
cs_malloc | CAPSTONE_EXPORT
cs_insn * CAPSTONE_API cs_malloc(csh ud)
{
cs_insn *insn;
struct cs_struct *handle = (struct cs_struct *)(uintptr_t)ud;
insn = cs_mem_malloc(sizeof(cs_insn));
if (!insn) {
// insufficient memory
handle->errnum = CS_ERR_MEM;
return NULL;
} else {
if (handle->detail) {
// allocate memory ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xf0, %edi
callq *0x158088(%rip) # 0x19c0b0
testq %rax, %rax
je 0x44057
movq %rax, %rbx
cmpl $0x0, 0x68(%r14)
je 0x44063
movl $0x5f8, %edi # imm = 0x5F8
callq *0x15806e(%rip) # 0x19c0b0
movq %rax, 0xe8(%rbx)
testq %rax, %rax
jne 0x4406e
m... | /TriDis[P]capstone/cs.c |
cs_op_index | CAPSTONE_API cs_op_index(csh ud, const cs_insn *insn, unsigned int op_type,
unsigned int post)
{
struct cs_struct *handle;
unsigned int count = 0, i;
if (!ud)
return -1;
handle = (struct cs_struct *)(uintptr_t)ud;
if (!handle->detail) {
handle->errnum = CS_ERR_DETAIL;
return -1;
}
if(!insn->id) {
ha... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x447b7
cmpl $0x0, 0x68(%rdi)
je 0x445f9
cmpl $0x0, (%rsi)
je 0x44601
movq 0xe8(%rsi), %rsi
testq %rsi, %rsi
je 0x445f9
movl $0x0, 0x58(%rdi)
movl (%rdi), %r8d
cmpq $0x7, %r8
ja 0x447b0
leaq 0x84e61(%rip), %rdi # 0xc9410
movslq (%rdi,%r8,4), %r8
ad... | /TriDis[P]capstone/cs.c |
SStream_concat | void SStream_concat(SStream *ss, const char *fmt, ...)
{
#ifndef CAPSTONE_DIET
va_list ap;
int ret;
va_start(ap, fmt);
ret = cs_vsnprintf(ss->buffer + ss->index, sizeof(ss->buffer) - (ss->index + 1), fmt, ap);
va_end(ap);
ss->index += ret;
#endif
} | pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r10
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x44997
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
m... | /TriDis[P]capstone/SStream.c |
printopaquemem | static void printopaquemem(MCInst *MI, unsigned OpNo, SStream *O)
{
switch(MI->csh->mode) {
case CS_MODE_16:
MI->x86opsize = 2;
break;
case CS_MODE_32:
MI->x86opsize = 4;
break;
case CS_MODE_64:
MI->x86opsize = 8;
break;
default: // never reach
break;
}
printMemReference(MI, OpNo, O);
} | movq 0x320(%rdi), %rax
movl 0x4(%rax), %eax
cmpl $0x2, %eax
je 0x4700a
cmpl $0x8, %eax
je 0x47006
cmpl $0x4, %eax
jne 0x46b44
movb $0x4, %al
jmp 0x4700c
movb $0x8, %al
jmp 0x4700c
movb $0x2, %al
movb %al, 0x328(%rdi)
jmp 0x46b44
| /TriDis[P]capstone/arch/X86/X86ATTInstPrinter.c |
printDstIdx | static void printDstIdx(MCInst *MI, unsigned Op, SStream *O)
{
if (MI->csh->detail) {
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize;
MI->flat_insn->detail->x86.operands[MI->... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x320(%rdi), %rax
cmpl $0x0, 0x68(%rax)
je 0x471a4
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x5c(%rax), %ecx
leaq (%rcx,%rcx,2), %rcx
shll $0x4, %ecx
movl $0x3, 0x60(%rax,%rcx)
movb 0x328(%rbx), %al
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), ... | /TriDis[P]capstone/arch/X86/X86ATTInstPrinter.c |
init | static cs_err init(cs_struct *ud)
{
MCRegisterInfo *mri;
// verify if requested mode is valid
if (ud->mode & ~(CS_MODE_BIG_ENDIAN | CS_MODE_V9))
return CS_ERR_MODE;
mri = cs_mem_malloc(sizeof(*mri));
Sparc_init(mri);
ud->printer = Sparc_printInst;
ud->printer_info = mri;
ud->getinsn_info = mri;
ud->disasm... | movl $0x5, %eax
testl $0x7fffffef, 0x4(%rdi) # imm = 0x7FFFFFEF
je 0x476a0
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x154a02(%rip), %rax # 0x19c0b0
movl $0x58, %edi
callq *(%rax)
movq %rax, %r14
movq %rax, %rdi
callq 0xabaee
leaq 0x64745(%rip), %rax # 0xabe0c
movq %rax, 0x8(%rbx)
movq %r14, 0x... | /TriDis[P]capstone/arch/Sparc/SparcModule.c |
MCRegisterInfo_InitMCRegisterInfo | void MCRegisterInfo_InitMCRegisterInfo(MCRegisterInfo *RI,
MCRegisterDesc *D, unsigned NR,
unsigned RA, unsigned PC,
MCRegisterClass *C, unsigned NC,
uint16_t (*RURoots)[2], unsigned NRU,
MCPhysReg *DL,
char *Strings,
uint16_t *SubIndices, unsigned NumIndices,
uint16_t *RET)
{
RI->Desc = D;
RI->NumReg... | pushq %rbp
pushq %r14
pushq %rbx
movq 0x58(%rsp), %rax
movl 0x50(%rsp), %r10d
movl 0x30(%rsp), %r11d
movq 0x28(%rsp), %rbx
movl 0x20(%rsp), %ebp
movaps 0x40(%rsp), %xmm0
movq 0x38(%rsp), %r14
movq %rsi, (%rdi)
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
movl %r8d, 0x10(%rdi)
movq %r9, 0x18(%rdi)
movq %r14, 0x30(%rdi)
mov... | /TriDis[P]capstone/MCRegisterInfo.c |
ARM_init | void ARM_init(MCRegisterInfo *MRI)
{
/*
InitMCRegisterInfo(ARMRegDesc, 289,
RA, PC,
ARMMCRegisterClasses, 100,
ARMRegUnitRoots, 77, ARMRegDiffLists, ARMRegStrings,
ARMSubRegIdxLists, 57,
ARMSubRegIdxRanges, ARMRegEncodingTable);
*/
MCRegisterInfo_InitMCRegisterInfo(MRI, ARMRegDesc, 289,
... | pushq %rax
xorl %eax, %eax
leaq 0x15cdce(%rip), %r10 # 0x1a48b0
leaq 0x15ad07(%rip), %r11 # 0x1a27f0
leaq 0x1586c0(%rip), %rsi # 0x1a01b0
leaq 0x159d59(%rip), %r9 # 0x1a1850
movl $0x121, %edx # imm = 0x121
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rax
pushq $0x39
pushq %r10
pushq %rax
pushq %r11
pu... | /TriDis[P]capstone/arch/ARM/ARMDisassembler.c |
UpdateThumbVFPPredicate | static void UpdateThumbVFPPredicate(cs_struct *ud, MCInst *MI)
{
unsigned CC;
unsigned short NumOps;
MCOperandInfo *OpInfo;
unsigned i;
CC = ITStatus_getITCC(&(ud->ITBlock));
if (ITStatus_instrInITBlock(&(ud->ITBlock)))
ITStatus_advanceITState(&(ud->ITBlock));
OpInfo = ARMInsts[MCInst_getOpcode(MI)].OpInfo;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl 0x64(%rdi), %eax
testl %eax, %eax
je 0x48956
leal -0x1(%rax), %ecx
movzbl 0x5c(%rdi,%rcx), %ebp
jmp 0x4895b
movl $0xe, %ebp
testl %eax, %eax
je 0x48964
decl %eax
movl %eax, 0x64(%rdi)
movq %rbx, %rdi
callq 0x4480d
movl %eax, %eax
imulq $0x38, %... | /TriDis[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeSORegImmOperand | static DecodeStatus DecodeSORegImmOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
ARM_AM_ShiftOpc Shift;
unsigned Op;
unsigned Rm = fieldFromInstruction_4(Val, 0, 4);
unsigned type = fieldFromInstruction_4(Val, 5, 2);
unsigned imm = fieldFrom... | pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %eax
andl $0xf, %eax
movl %esi, %r15d
shrl $0x5, %r15d
andl $0x3, %r15d
leaq 0x85e21(%rip), %rcx # 0xd69f0
movzwl (%rcx,%rax,2), %esi
callq 0x4489d
leaq 0x83a0d(%rip), %rax # 0xd45ec
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rc... | /TriDis[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeGPRnopcRegisterClass | static DecodeStatus DecodeGPRnopcRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
if (RegNo == 15)
S = MCDisassembler_SoftFail;
Check(&S, DecodeGPRRegisterClass(Inst, RegNo, Address, Decoder));
return S;
} | pushq %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
xorl %ebx, %ebx
cmpl $0xf, %esi
setne %bpl
ja 0x50cf2
movl %esi, %eax
leaq 0x85d0c(%rip), %rcx # 0xd69f0
movzwl (%rcx,%rax,2), %esi
callq 0x4489d
movl $0x3, %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x50d06
movb %bpl, %bl
leal 0x1(,%rbx,2), %eax
jmp 0x50d08
test... | /TriDis[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeCPSInstruction | static DecodeStatus DecodeCPSInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned imod = fieldFromInstruction_4(Insn, 18, 2);
unsigned M = fieldFromInstruction_4(Insn, 17, 1);
unsigned iflags = fieldFromInstruction_4(Insn, 6, 3);
unsigned mode = fieldFromInstruction_4(Insn, 0... | xorl %eax, %eax
testl $0x10020, %esi # imm = 0x10020
je 0x51212
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
shrl $0x12, %r15d
andl $0x3, %r15d
movl %esi, %ecx
andl $0xff00000, %ecx # imm = 0xFF00000
cmpl $0x1000000, %ecx # imm = 0x1000000
setne %cl
cmpl $0x1, %r15... | /TriDis[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeIT | static DecodeStatus DecodeIT(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred = fieldFromInstruction_4(Insn, 4, 4);
unsigned mask = fieldFromInstruction_4(Insn, 0, 4);
if (pred == 0xF) {
pred = 0xE;
S = MCDisassembler_SoftFail;
}
... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
andl $0xf, %r14d
je 0x545ae
movq %rdi, %rbx
shrl $0x4, %esi
andl $0xf, %esi
xorl %ecx, %ecx
cmpl $0xf, %esi
setne %cl
movl $0xe, %eax
cmovnel %esi, %eax
leal 0x1(,%rcx,2), %ebp
movq %rax, %rsi
callq 0x448ca
movl %r14d, %esi
movq %rbx, %rdi
callq 0x448ca
jmp 0x545b0
xorl... | /TriDis[P]capstone/arch/ARM/ARMDisassembler.c |
printVectorListTwoAllLanes | static void printVectorListTwoAllLanes(MCInst *MI, unsigned OpNum,
SStream *O, MCRegisterInfo *MRI)
{
unsigned Reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
unsigned Reg0 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_0);
unsigned Reg1 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_1);
SStream_concat0(O, "{... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x44814
movq %rax, %rdi
callq 0x4486a
movl %eax, %ebp
movq %r12, %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x47a0e
movl %eax, %r15d
movq %r12, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0x47a0e
... | /TriDis[P]capstone/arch/ARM/ARMInstPrinter.c |
printVectorListTwoSpacedAllLanes | static void printVectorListTwoSpacedAllLanes(MCInst *MI,
unsigned OpNum, SStream *O, MCRegisterInfo *MRI)
{
unsigned Reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
unsigned Reg0 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_0);
unsigned Reg1 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_2);
SStream_concat0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x44814
movq %rax, %rdi
callq 0x4486a
movl %eax, %ebp
movq %r12, %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x47a0e
movl %eax, %r15d
movq %r12, %rdi
movl %ebp, %esi
movl $0x3, %edx
callq 0x47a0e
... | /TriDis[P]capstone/arch/ARM/ARMInstPrinter.c |
printAddrMode6Operand | static void printAddrMode6Operand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
unsigned tmp;
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x44814
movq %rax, %r12
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x44814
movq %rax, %r15
leaq 0x805ac(%rip), %rsi # 0xe60d3
movq %r14, %rdi
callq 0x448f2
movq %rbx, %rdi
movl $0x... | /TriDis[P]capstone/arch/ARM/ARMInstPrinter.c |
printVectorListFourSpacedAllLanes | static void printVectorListFourSpacedAllLanes(MCInst *MI,
unsigned OpNum, SStream *O)
{
// Normally, it's not safe to use register enum values directly with
// addition to get the next register, but for VFP registers, the
// sort order is guaranteed because they're all of the form D<n>.
SStream_concat0(O, "{");
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x76fd5(%rip), %rsi # 0xdd2f4
movq %rbx, %rdi
callq 0x448f2
movq 0x320(%r14), %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x44814
movq %rax, %rdi
callq 0x4486a
movl %eax, %edi
callq *0x80(%r15)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x448f2
movq 0x... | /TriDis[P]capstone/arch/ARM/ARMInstPrinter.c |
printVectorListFourSpaced | static void printVectorListFourSpaced(MCInst *MI, unsigned OpNum, SStream *O)
{
// Normally, it's not safe to use register enum values directly with
// addition to get the next register, but for VFP registers, the
// sort order is guaranteed because they're all of the form D<n>.
SStream_concat0(O, "{");
printRegNa... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x76d1a(%rip), %rsi # 0xdd2f4
movq %rbx, %rdi
callq 0x448f2
movq 0x320(%r14), %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x44814
movq %rax, %rdi
callq 0x4486a
movl %eax, %edi
callq *0x80(%r15)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x448f2
movq 0x... | /TriDis[P]capstone/arch/ARM/ARMInstPrinter.c |
printCoprocOptionImm | static void printCoprocOptionImm(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned tmp = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "{0x%x}", tmp);
else
SStream_concat(O, "{%u}", tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI-... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x3, %esi
callq 0x44814
movq %rax, %rdi
callq 0x44872
movq %rax, %r14
cmpl $0xa, %r14d
leaq 0x764ef(%rip), %rax # 0xdd59e
leaq 0x764ef(%rip), %rsi # 0xdd5a5
cmovaeq %rax, %rsi
movq %r15, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x44939
mo... | /TriDis[P]capstone/arch/ARM/ARMInstPrinter.c |
printNoHashImmediate | static void printNoHashImmediate(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned tmp = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "0x%x", tmp);
else
SStream_concat(O, "%u", tmp);
if (MI->csh->detail) {
if (MI->csh->doing_mem) {
MI->flat_insn-... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
callq 0x44814
movq %rax, %rdi
callq 0x44872
movq %rax, %r14
cmpl $0xa, %r14d
leaq 0x87c01(%rip), %rax # 0xef5f9
leaq 0x6b737(%rip), %rsi # 0xd3136
cmovaeq %rax, %rsi
movq %r15, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x44939
movq 0x320(%rbx), ... | /TriDis[P]capstone/arch/ARM/ARMInstPrinter.c |
printAddrMode2OffsetOperand | static void printAddrMode2OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
ARM_AM_AddrOpc subtracted = getAM2Op((unsigned int)MCOperand_getImm(MO2));
if (!MCOperand_getReg(MO1)) {
unsigned ImmOffs = getAM2Offse... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3, %esi
callq 0x44814
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x44814
movq %rax, %r15
movq %rax, %rdi
callq 0x44872
movq %rax, %r13
shrl $0xc, %r13d
andl $0x1, %r13d
movl %r13d, %ebp
xorl $... | /TriDis[P]capstone/arch/ARM/ARMInstPrinter.c |
printPKHASRShiftImm | static void printPKHASRShiftImm(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned Imm = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
// A shift amount of 32 is encoded as 0.
if (Imm == 0)
Imm = 32;
//assert(Imm > 0 && Imm <= 32 && "Invalid PKH shift immediate value!");
if (Imm > HEX_THRESHOLD)
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3, %esi
callq 0x44814
movq %rax, %rdi
callq 0x44872
testl %eax, %eax
movl $0x20, %ebp
cmovnel %eax, %ebp
cmpl $0xa, %ebp
leaq 0x74b3b(%rip), %rax # 0xdd5ba
leaq 0x74b40(%rip), %rsi # 0xdd5c6
cmovaeq %rax, %rsi
movq %r14, %rdi
movl %ebp, %e... | /TriDis[P]capstone/arch/ARM/ARMInstPrinter.c |
printT2AddrModeImm8s4OffsetOperand | static void printT2AddrModeImm8s4OffsetOperand(MCInst *MI,
unsigned OpNum, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
int32_t OffImm = (int32_t)MCOperand_getImm(MO1);
//assert(((OffImm & 0x3) == 0) && "Not a valid immediate!");
SStream_concat0(O, ", ");
if (OffImm == INT32_MIN) {
SStream_co... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x4, %esi
callq 0x44814
movq %rax, %rdi
callq 0x44872
movq %rax, %r14
leaq 0x748bb(%rip), %rsi # 0xdd3c2
movq %r15, %rdi
callq 0x448f2
movl %r14d, %edx
negl %edx
jno 0x68b31
leaq 0x74a99(%rip), %rsi # 0xdd5b6
movq %r15, %rdi
callq 0x448f2
mo... | /TriDis[P]capstone/arch/ARM/ARMInstPrinter.c |
DecodeSystemPStateInstruction | static DecodeStatus DecodeSystemPStateInstruction(MCInst *Inst,
uint32_t insn, uint64_t Addr,
void *Decoder)
{
uint32_t op1 = fieldFromInstruction(insn, 16, 3);
uint32_t op2 = fieldFromInstruction(insn, 5, 3);
uint32_t crm = fieldFromInstruction(insn, 8, 4);
bool ValidNamed;
uint32_t pstate_field = (op1 << 3) ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
shrl $0x5, %eax
andl $0x7, %eax
movl %esi, %r15d
shrl $0x8, %r15d
andl $0xf, %r15d
shrl $0xd, %ebx
andl $0x38, %ebx
orl %eax, %ebx
movq %rbx, %rsi
callq 0x448ca
movq %r14, %rdi
movq %r15, %rsi
callq 0x448ca
leaq 0x2225c0(%... | /TriDis[P]capstone/arch/AArch64/AArch64Disassembler.c |
AArch64_printInst | void AArch64_printInst(MCInst *MI, SStream *O, void *Info)
{
// Check for special encodings and print the canonical alias instead.
unsigned Opcode = MCInst_getOpcode(MI);
int LSB;
int Width;
char *mnem;
if (Opcode == AArch64_SYSxt && printSysAlias(MI, O))
return;
// SBFM/UBFM should print to a nicer aliased ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, 0x28(%rsp)
callq 0x4480d
movq %rax, 0x20(%rsp)
cmpl $0x7c2, %eax # imm = 0x7C2
jne 0x6dac1
movq %r12, 0x38(%rsp)
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44814
... | /TriDis[P]capstone/arch/AArch64/AArch64InstPrinter.c |
getWRegFromXReg | inline static unsigned getWRegFromXReg(unsigned Reg)
{
switch (Reg) {
case ARM64_REG_X0: return ARM64_REG_W0;
case ARM64_REG_X1: return ARM64_REG_W1;
case ARM64_REG_X2: return ARM64_REG_W2;
case ARM64_REG_X3: return ARM64_REG_W3;
case ARM64_REG_X4: return ARM64_REG_W4;
case ARM64_REG_X5: return ARM64_REG_W... | movl %edi, %eax
leal -0xc7(%rax), %ecx
cmpl $0x1c, %ecx
ja 0x6e95c
leaq 0x70a77(%rip), %rax # 0xdf3c4
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0xa8, %eax
retq
leal -0x1(%rax), %ecx
cmpl $0x6, %ecx
ja 0x6e95b
leaq 0x70a3d(%rip), %rdx # 0xdf3a8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%... | /TriDis[P]capstone/arch/AArch64/AArch64BaseInfo.h |
printOperand | static void printOperand(MCInst *MI, unsigned OpNo, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNo);
if (MCOperand_isReg(Op)) {
unsigned Reg = MCOperand_getReg(Op);
SStream_concat0(O, getRegisterName(Reg, AArch64_NoRegAltName));
if (MI->csh->detail) {
if (MI->csh->doing_mem) {
if (MI->flat_ins... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
callq 0x44814
movq %rax, %r14
movq %rax, %rdi
callq 0x44852
testb %al, %al
je 0x87f34
movq %r14, %rdi
callq 0x4486a
movl %eax, %r14d
leal -0x1(%r14), %eax
leaq 0x5d0ec(%rip), %rcx # 0xe4fb0
movl (%rcx,%rax,4), %eax
leaq 0x1554b2(%rip), %rsi # 0x1dd... | /TriDis[P]capstone/arch/AArch64/AArch64InstPrinter.c |
printAdrpLabel | static void printAdrpLabel(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNum);
if (MCOperand_isImm(Op)) {
// ADRP sign extends a 21-bit offset, shifts it left by 12
// and adds it to the value of the PC with its bottom 12 bits cleared
uint64_t imm = (MCOperand_getImm(Op) << ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %esi
callq 0x44814
movq %rax, %r14
movq %rax, %rdi
callq 0x4485a
testb %al, %al
je 0x88a15
movq %r14, %rdi
callq 0x44872
shlq $0xc, %rax
movq $-0x1000, %r14 # imm = 0xF000
andq 0x318(%rbx), %r14
addq %rax, %r14
leaq 0x40ccd(%rip), %rax... | /TriDis[P]capstone/arch/AArch64/AArch64InstPrinter.c |
DecodeGPR64RegisterClass | static DecodeStatus DecodeGPR64RegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder)
{
unsigned Reg;
if (RegNo > 31)
return MCDisassembler_Fail;
Reg = getReg(Decoder, Mips_GPR64RegClassID, RegNo);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
} | xorl %eax, %eax
cmpl $0x1f, %esi
ja 0x8d5bc
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
movl $0x1c, %esi
callq 0x47a7b
movq 0x8(%rax), %rax
movl %ebp, %ecx
movzwl (%rax,%rcx,2), %esi
movq %rbx, %rdi
callq 0x4489d
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /TriDis[P]capstone/arch/Mips/MipsDisassembler.c |
DecodeCCRRegisterClass | static DecodeStatus DecodeCCRRegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder)
{
unsigned Reg;
if (RegNo > 31)
return MCDisassembler_Fail;
Reg = getReg(Decoder, Mips_CCRRegClassID, RegNo);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
} | xorl %eax, %eax
cmpl $0x1f, %esi
ja 0x8d6a4
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
movl $0x1, %esi
callq 0x47a7b
movq 0x8(%rax), %rax
movl %ebp, %ecx
movzwl (%rax,%rcx,2), %esi
movq %rbx, %rdi
callq 0x4489d
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /TriDis[P]capstone/arch/Mips/MipsDisassembler.c |
printMemRegReg | static void printMemRegReg(MCInst *MI, unsigned OpNo, SStream *O)
{
// When used as the base register, r0 reads constant zero rather than
// the value contained in the register. For this reason, the darwin
// assembler requires that we print r0 as 0 (no r) when used as the base.
if (MCOperand_getReg(MCInst_getOper... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x44814
movq %rax, %rdi
callq 0x4486a
cmpl $0x36, %eax
jne 0xa3e71
leaq 0x4c1d0(%rip), %rsi # 0xf0037
movq %rbx, %rdi
callq 0x448f2
jmp 0xa3e7e
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x932c4
leaq 0x3953d(%rip), %rs... | /TriDis[P]capstone/arch/PowerPC/PPCInstPrinter.c |
PPC_insn_name | const char *PPC_insn_name(csh handle, unsigned int id)
{
#ifndef CAPSTONE_DIET
unsigned int i;
if (id >= PPC_INS_ENDING)
return NULL;
// handle special alias first
for (i = 0; i < ARR_SIZE(alias_insn_names); i++) {
if (alias_insn_names[i].id == id)
return alias_insn_names[i].name;
}
return insn_name_map... | leal -0x3a6(%rsi), %eax
cmpl $0xfffffc5b, %eax # imm = 0xFFFFFC5B
jae 0xa44ac
xorl %eax, %eax
retq
movl %esi, %eax
shlq $0x4, %rax
leaq 0x179a77(%rip), %rcx # 0x21df30
movq 0x8(%rax,%rcx), %rax
retq
| /TriDis[P]capstone/arch/PowerPC/PPCMapping.c |
printAVXCC | static void printAVXCC(MCInst *MI, unsigned Op, SStream *O)
{
int64_t Imm = MCOperand_getImm(MCInst_getOperand(MI, Op)) & 0x1f;
switch (Imm) {
default: break;//printf("Invalid avxcc argument!\n"); break;
case 0: SStream_concat0(O, "eq"); op_addAvxCC(MI, X86_AVX_CC_EQ); break;
case 1: SStream_concat0(O, "l... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0x44814
movq %rax, %rdi
callq 0x44872
andl $0x1f, %eax
leaq 0xa58e6(%rip), %rcx # 0x14f260
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leal 0x1(%rax), %ebp
movq %rbx, %rdi
callq 0x448f2
movq %r14, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rb... | /TriDis[P]capstone/arch/X86/X86IntelInstPrinter.c |
DecodeMem | static DecodeStatus DecodeMem(MCInst *MI, unsigned insn, uint64_t Address,
const void *Decoder,
bool isLoad, DecodeFunc DecodeRD)
{
DecodeStatus status;
unsigned rd = fieldFromInstruction_4(insn, 25, 5);
unsigned rs1 = fieldFromInstruction_4(insn, 14, 5);
bool isImm = fieldFromInstruction_4(insn, 13, 1) != 0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %rcx, %r13
movl %esi, %ebx
movq %rdi, %r12
movl %esi, %ebp
shrl $0x19, %ebp
andl $0x1f, %ebp
movl %esi, %eax
andl $0x1f, %eax
xorl %r14d, %r14d
btl $0xd, %esi
cmovael %eax, %r14d
movl %r8d, 0xc(%rsp)
testl %r8d, %r8d
... | /TriDis[P]capstone/arch/Sparc/SparcDisassembler.c |
printS16ImmOperand | static void printS16ImmOperand(MCInst *MI, int OpNum, SStream *O)
{
int16_t Value = (int16_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
// assert(isInt<16>(Value) && "Invalid s16imm argument");
if (Value >= 0) {
if (Value > HEX_THRESHOLD)
SStream_concat(O, "0x%x", Value);
else
SStream_concat(O, "%u",... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
callq 0x44814
movq %rax, %rdi
callq 0x44872
movq %rax, %r14
movswl %r14w, %edx
testw %r14w, %r14w
js 0xc51d3
cmpw $0xa, %r14w
jl 0xc51e6
leaq 0x2a428(%rip), %rsi # 0xef5f9
jmp 0xc51ed
movl %edx, %eax
negl %eax
cmpw $-0xa, %dx
jg 0xc51f2
leaq 0x182c3(%... | /TriDis[P]capstone/arch/SystemZ/SystemZInstPrinter.c |
printAddress | static void printAddress(MCInst *MI, unsigned Base, int64_t Disp, unsigned Index, SStream *O)
{
if (Disp >= 0) {
if (Disp > HEX_THRESHOLD)
SStream_concat(O, "0x%"PRIx64, Disp);
else
SStream_concat(O, "%"PRIu64, Disp);
} else {
if (Disp < -HEX_THRESHOLD)
SStream_concat(O, "-0x%"PRIx64, -Disp);
else
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r13
movl %ecx, %r15d
movq %rdx, %rbx
movl %esi, %r12d
movq %rdi, %r14
testq %rdx, %rdx
js 0xc56bf
cmpq $0xa, %rbx
jl 0xc56d4
leaq 0x89cc8(%rip), %rsi # 0x14f385
jmp 0xc56db
movq %rbx, %rdx
negq %rdx
cmpq $-0xa, %rbx
jg 0xc56e3
leaq 0x3fa1(%rip), %rsi... | /TriDis[P]capstone/arch/SystemZ/SystemZInstPrinter.c |
DecodeL5RInstruction | static DecodeStatus DecodeL5RInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3, Op4, Op5;
DecodeStatus S =
Decode3OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2, &Op3);
if (S != MCDisassembler_Success)
return DecodeL5RInstructionFail(Inst, Insn, A... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %eax
shrl $0x6, %eax
andl $0x1f, %eax
cmpl $0x1a, %eax
ja 0xc6fdb
movl %eax, %edx
imulq $0x55555556, %rdx, %rcx # imm = 0x55555556
shrq $0x20, %rcx
leal (%rcx,%rcx,2), %esi
movl %eax, ... | /TriDis[P]capstone/arch/XCore/XCoreDisassembler.c |
ncnn::Dropout::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Dropout::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
if (scale == 1.f)
{
return 0;
}
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for ... | movss 0x3dfde(%rip), %xmm0 # 0x6f050
ucomiss 0xb8(%rdi), %xmm0
je 0x310c7
movslq 0x34(%rsi), %rax
testq %rax, %rax
jle 0x310c7
movl 0x30(%rsi), %ecx
imull 0x2c(%rsi), %ecx
movq (%rsi), %rdx
movq 0x38(%rsi), %r8
imulq 0x10(%rsi), %r8
xorl %esi, %esi
testl %ecx, %ecx
jle 0x310bc
xorl %r9d, %r9d
movss 0xb8(%rdi), %xmm0... | /xiangweizeng[P]ncnn/src/layer/dropout.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.