name string | code string | asm string | file string |
|---|---|---|---|
unsigned int NJamSpell::GetGramHashCount<unsigned int>(unsigned int, NJamSpell::TPerfectHash const&, std::vector<std::pair<unsigned short, unsigned short>, std::allocator<std::pair<unsigned short, unsigned short>>> const&) | TCount GetGramHashCount(T key,
const TPerfectHash& ph,
const std::vector<std::pair<uint16_t, uint16_t>>& buckets)
{
constexpr int TMP_BUF_SIZE = 128;
static char tmpBuff[TMP_BUF_SIZE];
static MemStream tmpBuffStream(tmpBuff, TMP_BUF_SIZE - 1);
static std::... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, -0x24(%rbp)
leaq 0x23690(%rip), %rax # 0x86be8
movb (%rax), %al
testb %al, %al
je 0x6361c
leaq 0x23797(%rip), %rax # 0x86d00
movb (%rax), %al
testb %al, %al
je 0x63670
leaq 0x23616(... | /imShayan[P]JamSpell/jamspell/lang_model.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> NJamSpell::DumpKey<unsigned int>(unsigned int const&) | std::string DumpKey(const T& key) {
std::stringbuf buf;
std::ostream out(&buf);
NHandyPack::Dump(out, key);
return buf.str();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x43a40
leaq -0x190(%rbp), %rdi
movq %r15, %rsi
callq 0x43260
leaq -0x190(%rbp), %rdi
movq %r14, %rsi
callq 0x45ca2
leaq -0x80(%rbp), %rsi
m... | /imShayan[P]JamSpell/jamspell/lang_model.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> NJamSpell::DumpKey<std::pair<unsigned int, unsigned int>>(std::pair<unsigned int, unsigned int> const&) | std::string DumpKey(const T& key) {
std::stringbuf buf;
std::ostream out(&buf);
NHandyPack::Dump(out, key);
return buf.str();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x43a40
leaq -0x190(%rbp), %rdi
movq %r15, %rsi
callq 0x43260
leaq -0x190(%rbp), %rdi
movq %r14, %rsi
callq 0x649d0
leaq -0x80(%rbp), %rsi
m... | /imShayan[P]JamSpell/jamspell/lang_model.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> NJamSpell::DumpKey<std::tuple<unsigned int, unsigned int, unsigned int>>(std::tuple<unsigned int, unsigned int, unsigned int> const&) | std::string DumpKey(const T& key) {
std::stringbuf buf;
std::ostream out(&buf);
NHandyPack::Dump(out, key);
return buf.str();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x43a40
leaq -0x190(%rbp), %rdi
movq %r15, %rsi
callq 0x43260
leaq -0x190(%rbp), %rdi
movq %r14, %rsi
callq 0x64a8c
leaq -0x80(%rbp), %rsi
m... | /imShayan[P]JamSpell/jamspell/lang_model.cpp |
tsl::detail_robin_hash::robin_hash<std::pair<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, unsigned int>, tsl::robin_map<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, unsigned int, std::hash<std::__cxx11::basic_string<wchar_t, std::ch... | iterator begin() noexcept {
auto begin = m_buckets.begin();
while(begin != m_buckets.end() && begin->empty()) {
++begin;
}
return iterator(begin);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
cmpq %rdx, %rcx
je 0x650e5
cmpw $-0x1, 0x4(%rcx)
jne 0x650e5
addq $0x30, %rcx
jmp 0x650d3
movq %rcx, (%rax)
popq %rbp
retq
| /imShayan[P]JamSpell/contrib/tsl/robin_hash.h |
tsl::detail_robin_hash::robin_hash<std::pair<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, unsigned int>, tsl::robin_map<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, unsigned int, std::hash<std::__cxx11::basic_string<wchar_t, std::ch... | const_iterator find_impl(const K& key, std::size_t hash) const {
std::size_t ibucket = bucket_for_hash(hash);
distance_type dist_from_ideal_bucket = 0;
while(dist_from_ideal_bucket <= m_buckets[ibucket].dist_from_ideal_bucket()) {
if((!USE_STORED_HASH_ON_LOOKUP || m_buckets... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andq (%rdi), %r14
xorl %r13d, %r13d
movq 0x8(%rbx), %rdi
imulq $0x30, %r14, %r12
cmpw 0x4(%rdi,%r12), %r13w
jg 0x65423
addq %r12, %rdi
addq $0x8, %rdi
movq %r15, %rsi
callq 0x44bf... | /imShayan[P]JamSpell/contrib/tsl/robin_hash.h |
NJamSpell::MemStream::xsputn(char const*, long) | std::streamsize xsputn(const char* s, std::streamsize n) override {
if (n <= 0) {
return n;
}
long toCopy = std::min<long>(n, MaxSize - Pos);
memcpy(Buff + Pos, s, toCopy);
Pos += toCopy;
return n;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rdx, %rdx
jle 0x655db
movq %rdi, %r14
movq 0x48(%rdi), %r15
movq 0x50(%rdi), %rdi
subq %rdi, %r15
cmpq %rbx, %r15
cmovgeq %rbx, %r15
addq 0x40(%r14), %rdi
movq %r15, %rdx
callq 0x43510
addq %r15, 0x50(%r14)
movq %rbx, %rax
add... | /imShayan[P]JamSpell/jamspell/lang_model.cpp |
NJamSpell::TTokenizer::TTokenizer() | TTokenizer::TTokenizer()
: Locale("en_US.utf-8")
{
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x1fe7c(%rip), %rax # 0x85570
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x38(%rdi), %rax
movq %rax, 0x8(%rdi)
movq $0x1, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl $0x3f800000, 0x28(%rdi) # imm = 0x3F800000
movups %xmm0, 0x30(... | /imShayan[P]JamSpell/jamspell/utils.cpp |
NJamSpell::TTokenizer::LoadAlphabet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool TTokenizer::LoadAlphabet(const std::string& alphabetFile) {
std::string data = LoadFile(alphabetFile);
if (data.empty()) {
return false;
}
std::wstring wdata = UTF8ToWide(data);
if (wdata.empty()) {
return false;
}
ToLower(wdata);
std::unordered_set<wchar_t> alphabet... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq -0x78(%rbp), %r14
movq %r14, %rdi
callq 0x655ec
cmpq $0x0, 0x8(%r14)
je 0x6582f
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x65893
cmpq $0x0, -0x50(%rbp)
je 0x65834
movq %rbx, -0x38(%rbp)
lea... | /imShayan[P]JamSpell/jamspell/utils.cpp |
main | int main (int argc, char const *argv[]) {
char *s = NULL;
CMimeAddress_T *ca = cmime_address_new();
cmime_address_set_name(ca, addr_string1_name_part);
cmime_address_set_email(ca, addr_string1_email_part);
s = cmime_address_to_string(ca);
assert(strcmp(s,addr_string1) == 0);
free(s... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x2090
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x2e9b(%rip), %rsi # 0x509d
callq 0x2030
movq -0x20(%rbp), %rdi
leaq 0x2e9e(%rip), %rsi # 0x50b0
callq 0x2070
mo... | /spmfilter[P]libcmime/test/test_address.c |
memcmp16_s | errno_t
memcmp16_s (const uint16_t *dest, rsize_t dmax,
const uint16_t *src, rsize_t smax, int *diff)
{
const uint16_t *dp;
const uint16_t *sp;
dp = dest;
sp = src;
/*
* must be able to return the diff
*/
if (diff == NULL) {
invoke_safe_mem_constraint_handler("m... | subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2329
leaq 0xdd22(%rip), %rdi # ... | /intel[P]safestringlib/safeclib/memcmp16_s.c |
memcmp32_s | errno_t
memcmp32_s (const uint32_t *dest, rsize_t dmax,
const uint32_t *src, rsize_t smax, int *diff)
{
/*
* must be able to return the diff
*/
if (diff == NULL) {
invoke_safe_mem_constraint_handler("memcmp32_s: diff is null",
NULL, ESNULLP);
return (RCN... | subq $0x48, %rsp
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2585
leaq 0xdb77(%rip), %rdi # 0x100e1
xorl %eax, %eax
movl %eax, %esi
movl $0x190, %edx # imm = 0x190
callq... | /intel[P]safestringlib/safeclib/memcmp32_s.c |
main | extern int main(int , char * const [])
{
float val;
mtrace();
const double d[] = { 1, -4, 78 };
mpt::source<double> sd(d, 3);
const int i[] = { 1, 2, 3, 4, 5 };
mpt::source<int> si(i, 5, -2);
mpt::iterator *src[] = { &sd, &si };
for (mpt::iterator *it : src) {
while (it->get(val)) {
std::cout << va... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
callq 0x20b0
movaps 0xe08(%rip), %xmm0 # 0x3010
leaq 0x40(%rsp), %rax
movaps %xmm0, (%rax)
movabsq $0x4053800000000000, %rcx # imm = 0x4053800000000000
movq %rcx, 0x10(%rax)
leaq 0x98(%rsp), %rcx
movq %rax, 0x8(%rcx)
movq $0x18, 0x10(%rcx)
lea... | /becm[P]mpt-base/examples/cxx/iter.cpp |
mpt::source<double>::advance() | int advance() __MPT_OVERRIDE
{
if (_pos < 0 || _pos >= span<const T>::size()) {
return MissingData;
}
_pos += _step;
if (_pos < 0 || _pos >= span<const T>::size()) {
return 0;
}
return _type ? _type : type_properties<struct value>::id(true);
} | movq 0x28(%rdi), %rcx
movl $0xfffffff0, %eax # imm = 0xFFFFFFF0
testq %rcx, %rcx
js 0x23c4
movq 0x10(%rdi), %rdx
shrq $0x3, %rdx
cmpq %rdx, %rcx
jae 0x23c4
movslq 0x30(%rdi), %rax
addq %rax, %rcx
movq %rcx, 0x28(%rdi)
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x23c4
movl 0x34(%rdi), %ecx
testl %ecx, %ecx
movl $0x19, %e... | /becm[P]mpt-base/mptcore/types.h |
main | int main() {
skiplist<int, std::string> aDict;
aDict.insert(10, "hello");
aDict.insert(20, "jello");
aDict.insert(20, "yello");
aDict.insert(40, "fello");
std::cout << aDict;
// foundit(aDict, DictKey{10});
// foundit(aDict, DictKey{20});
// foundit(aDict, DictKey{30});
std::cout << "SKIPLIST:\n"... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xae8, %rsp # imm = 0xAE8
leaq 0xe0(%rsp), %rdi
callq 0x297e
leaq 0x1cbf(%rip), %rsi # 0x4050
leaq 0xc0(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x2060
leaq 0xe0(%rsp), %rdi
pushq $0xa
popq %rsi
leaq 0xc0(%rsp), %rdx
callq 0x29d2
lea... | /Samyak2[P]skip-list/examples/dictionary_map.cpp |
std::ostream& operator<<<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<int>>(std::ostream&, skiplist<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<int>> const&) | std::ostream &operator<<(std::ostream &out, const skiplist<T, V, X>& sl) {
if (sl.key.empty()) {
return out << "EMPTY SKIPLIST" << std::endl;
}
out << "Values: ";
// store mapping of node->index in a map
std::map<T, int> index_store{};
auto bottom_it = (*(sl.key.begin()))->next;
int... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x2f30
movq %rsi, %r14
leaq 0x136b(%rip), %rsi # 0x40c8
movq %rbx, %rdi
callq 0x2150
leaq 0x28(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rax)
andq $0x0, 0x8(%rax)
mo... | /Samyak2[P]skip-list/skiplist/skiplist_map.hpp |
skiplist<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<int>>::find(int) | typename skiplist<T, V, X>::iterator skiplist<T, V, X>::find(T find_key) {
// Same algorithm as erase, but without erasing anything ;)
if(key.empty())
return end();
// Start from top left
SLNode<T, V>* follow = key.back();
// Go on till level 0
while(follow->down) {
while(follow... | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq %rax, (%rsi)
je 0x3066
addq $-0x8, %rax
movq (%rax), %rsi
cmpq $0x0, 0x18(%rsi)
je 0x304f
movq %rsi, %rax
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x3044
cmpl %edx, 0x20(%rsi)
jl 0x3033
addq $0x18, %rax
jmp 0x3029
cmpl %edx, 0x20(%rsi)
jge 0x305a
movq 0x8(%rsi), %rsi... | /Samyak2[P]skip-list/skiplist/skiplist_map.hpp |
skiplist<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<int>>::destroy_all_levels() | void destroy_all_levels() {
SLNode<key_type, val_type> *tmp;
for(auto level: key)
while(level) {
tmp = level->next;
delete level;
level = tmp;
}
key.clear();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r12, %r15
je 0x32ae
movq (%r15), %r14
testq %r14, %r14
je 0x32a8
movq 0x8(%r14), %r13
leaq 0x28(%r14), %rdi
callq 0x32c6
movq %r14, %rdi
callq 0x2140
movq %r13, %r14
jmp 0x3289
addq $0x8, %r15
jmp 0x3281
... | /Samyak2[P]skip-list/skiplist/skiplist_map.hpp |
main | int main() {
vkb::InstanceBuilder instance_builder;
auto system_info_ret = vkb::SystemInfo::get_system_info();
if (!system_info_ret) {
std::cerr << system_info_ret.error().message().c_str() << "\n";
return -1;
}
auto system_info = system_info_ret.value();
// check for a layer
... | pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
leaq 0xf8(%rsp), %rdi
callq 0x4762
leaq 0xb8(%rsp), %rdi
callq 0x420c
cmpb $0x0, 0xf0(%rsp)
je 0x374f
leaq 0x48(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x3a62
leaq 0x60(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x3afa
movq 0xe8(%rsp), %rax
leaq 0x48(%rsp), %rdi
movq %... | /charles-lunarg[P]vk-bootstrap/example/system_info.cpp |
vkb::detail::GenericFeatureChain::match_all(vkb::detail::GenericFeatureChain const&) const | bool GenericFeatureChain::match_all(GenericFeatureChain const& extension_requested) const noexcept {
// Should only be false if extension_supported was unable to be filled out, due to the
// physical device not supporting vkGetPhysicalDeviceFeatures2 in any capacity.
if (extension_requested.nodes.size() != ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%rsi), %rdi
movq 0x8(%rsi), %rax
movq %rax, %rcx
subq %rdi, %rcx
movq 0x8(%r15), %rdx
subq (%r15), %rdx
cmpq %rdx, %rcx
jne 0x3e03
movb $0x1, %bl
cmpq %rdi, %rax
je 0x3e05
movq %rsi, %r14
xorl %r12d, %r12d
movabsq $0xfc0f... | /charles-lunarg[P]vk-bootstrap/src/VkBootstrap.cpp |
vkb::SystemInfo::get_system_info() | Result<SystemInfo> SystemInfo::get_system_info() {
if (!detail::vulkan_functions().init_vulkan_funcs(nullptr)) {
return make_error_code(InstanceError::vulkan_unavailable);
}
return SystemInfo();
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x1bf6b(%rip), %rdi # 0x20188
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xa472
testb %al, %al
je 0x425d
movq %rsp, %r14
movq %r14, %rdi
callq 0x42ec
movaps (%r14), %xmm0
movups %xmm0, (%rbx)
movaps 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movaps 0x20(%r14)... | /charles-lunarg[P]vk-bootstrap/src/VkBootstrap.cpp |
vkb::SystemInfo::SystemInfo() | SystemInfo::SystemInfo() {
auto available_layers_ret = detail::get_vector<VkLayerProperties>(
this->available_layers, detail::vulkan_functions().fp_vkEnumerateInstanceLayerProperties);
if (available_layers_ret != VK_SUCCESS) {
this->available_layers.clear();
}
for (auto& layer : this->a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
pxor %xmm0, %xmm0
movdqu %xmm0, 0x20(%rdi)
movdqu %xmm0, 0x10(%rdi)
movdqu %xmm0, (%rdi)
movw $0x0, 0x30(%rdi)
movl $0x400000, 0x34(%rdi) # imm = 0x400000
leaq 0x1bea9(%rip), %rsi # 0x201d0
cal... | /charles-lunarg[P]vk-bootstrap/src/VkBootstrap.cpp |
vkb::InstanceBuilder::build() const | Result<Instance> InstanceBuilder::build() const {
auto sys_info_ret = SystemInfo::get_system_info(info.fp_vkGetInstanceProcAddr);
if (!sys_info_ret) return sys_info_ret.error();
auto system = sys_info_ret.value();
uint32_t instance_version = VKB_VK_API_VERSION_1_0;
if (info.minimum_instance_versi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rsi, %rbp
movq %rdi, %r14
movq 0xe0(%rsi), %rsi
leaq 0x1b0(%rsp), %r15
movq %r15, %rdi
callq 0x427e
cmpb $0x0, 0x38(%r15)
je 0x48e8
leaq 0x80(%rsp), %rdi
leaq 0x1b0(%rsp), %rsi
callq 0x3a62
leaq 0x98(%rsp)... | /charles-lunarg[P]vk-bootstrap/src/VkBootstrap.cpp |
vkb::InstanceBuilder::enable_extension(char const*) | InstanceBuilder& InstanceBuilder::enable_extension(const char* extension_name) {
if (!extension_name) return *this;
info.extensions.push_back(extension_name);
return *this;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0x5545
movq 0x40(%rbx), %rax
cmpq 0x48(%rbx), %rax
je 0x5534
movq %rsi, (%rax)
addq $0x8, 0x40(%rbx)
jmp 0x5545
leaq 0x38(%rbx), %rdi
leaq 0x8(%rsp), %rdx
movq %rax, %rsi
callq 0x10160
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /charles-lunarg[P]vk-bootstrap/src/VkBootstrap.cpp |
vkb::InstanceBuilder::enable_extensions(unsigned long, char const* const*) | InstanceBuilder& InstanceBuilder::enable_extensions(size_t count, const char* const* extensions) {
if (!extensions || count == 0) return *this;
for (size_t i = 0; i < count; i++) {
info.extensions.push_back(extensions[i]);
}
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rdx, %rdx
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x5606
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x38(%r14), %r12
movq 0x40(%r14), %rsi
cmpq 0x48(%r14), %rsi
je 0x55f2
movq (%rbx), %rax
movq %rax, (%rsi)
addq $0x8, 0x40(%r14)
jmp 0x5... | /charles-lunarg[P]vk-bootstrap/src/VkBootstrap.cpp |
vkb::InstanceBuilder::add_validation_feature_enable(VkValidationFeatureEnableEXT) | InstanceBuilder& InstanceBuilder::add_validation_feature_enable(VkValidationFeatureEnableEXT enable) {
info.enabled_validation_features.push_back(enable);
return *this;
} | pushq %rbx
subq $0x10, %rsp
movl %esi, %eax
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movq 0xa8(%rdi), %rsi
cmpq 0xb0(%rdi), %rsi
je 0x5701
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xa8(%rbx)
jmp 0x5712
leaq 0xa0(%rbx), %rdi
leaq 0xc(%rsp), %rdx
callq 0x10660
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
| /charles-lunarg[P]vk-bootstrap/src/VkBootstrap.cpp |
vkb::detail::combine_features(VkPhysicalDeviceFeatures&, VkPhysicalDeviceFeatures) | void combine_features(VkPhysicalDeviceFeatures& dest, VkPhysicalDeviceFeatures src){
dest.robustBufferAccess = dest.robustBufferAccess || src.robustBufferAccess;
dest.fullDrawIndexUint32 = dest.fullDrawIndexUint32 || src.fullDrawIndexUint32;
dest.imageCubeArray = dest.imageCubeArray || src.imageCubeArray;
dest.i... | pxor %xmm0, %xmm0
movdqu (%rdi), %xmm5
movdqu 0x10(%rdi), %xmm4
movdqu 0x20(%rdi), %xmm3
movdqu 0x30(%rdi), %xmm2
pcmpeqd %xmm0, %xmm5
pcmpeqd %xmm1, %xmm1
pxor %xmm1, %xmm5
movdqa 0x8(%rsp), %xmm6
pcmpeqd %xmm0, %xmm6
por %xmm5, %xmm6
pxor %xmm1, %xmm6
psrld $0x1f, %xmm6
psubd %xmm5, %xmm6
movdqu %xmm6, (%rdi)
pcmpeqd... | /charles-lunarg[P]vk-bootstrap/src/VkBootstrap.cpp |
vkb::detail::get_separate_queue_index(std::vector<VkQueueFamilyProperties, std::allocator<VkQueueFamilyProperties>> const&, unsigned int, unsigned int) | uint32_t get_separate_queue_index(
std::vector<VkQueueFamilyProperties> const& families, VkQueueFlags desired_flags, VkQueueFlags undesired_flags) {
uint32_t index = QUEUE_INDEX_MAX_VALUE;
for (uint32_t i = 0; i < static_cast<uint32_t>(families.size()); i++) {
if ((families[i].queueFlags & desired_f... | movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
subq %rcx, %rdi
sarq $0x3, %rdi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rax
testl %eax, %eax
je 0x5f53
movl %eax, %edi
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %r8d, %r8d
movl (%rcx), %r9d
movl %r9d, %r10d
notl %r10d
testl %r10d, %esi... | /charles-lunarg[P]vk-bootstrap/src/VkBootstrap.cpp |
CheckPut | static void CheckPut(void* ptr,
const char* k, size_t klen,
const char* v, size_t vlen) {
int* state = (int*) ptr;
CheckCondition(*state < 2);
switch (*state) {
case 0:
CheckEqual("bar", k, klen);
CheckEqual("b", v, vlen);
break;
case 1:
Ch... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x2, (%rax)
jl 0xa044
movq 0x67fcc(%rip), %rax # 0x71fe0
movq (%rax), %rdi
movq 0x684... | /CDDSCLab[P]leveldb/db/c_test.c |
leveldb_filterpolicy_create | leveldb_filterpolicy_t* leveldb_filterpolicy_create(
void* state, void (*destructor)(void*),
char* (*create_filter)(void*, const char* const* key_array,
const size_t* key_length_array, int num_keys,
size_t* filter_length),
unsigned char (*key_may_match)(... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x30, %edi
callq 0x7430
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
callq 0xc130
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movq -0x30(%r... | /CDDSCLab[P]leveldb/db/c.cc |
leveldb::DBImpl::RecoverLogFile(unsigned long, bool, bool*, leveldb::VersionEdit*, unsigned long*)::LogReporter::Corruption(unsigned long, leveldb::Status const&) | void Corruption(size_t bytes, const Status& s) override {
Log(info_log, "%s%s: dropping %d bytes; %s",
(this->status == nullptr ? "(ignoring error) " : ""), fname,
static_cast<int>(bytes), s.ToString().c_str());
if (this->status != nullptr && this->status->ok()) *this->status = s;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x20(%rax), %rcx
testq %rcx, %rcx
leaq 0x400a5(%rip), %rdx # 0x5013f
leaq 0x3f732(%rip), %rcx # 0x4f7d3
cmoveq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq ... | /CDDSCLab[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::NewInternalIterator(leveldb::ReadOptions const&, unsigned long*, unsigned int*) | Iterator* DBImpl::NewInternalIterator(const ReadOptions& options,
SequenceNumber* latest_snapshot,
uint32_t* seed) {
mutex_.Lock();
*latest_snapshot = versions_->LastSequence();
// Collect together all needed child iterators
std::vecto... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0xc8, %rdi
callq 0x17550
movq -0x78(%rbp), %rax
movq 0x228(%rax), %rdi
callq 0x17eb0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx,... | /CDDSCLab[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::BuildBatchGroup(leveldb::DBImpl::Writer**) | WriteBatch* DBImpl::BuildBatchGroup(Writer** last_writer) {
mutex_.AssertHeld();
assert(!writers_.empty());
Writer* first = writers_.front();
WriteBatch* result = first->batch;
assert(result != nullptr);
size_t size = WriteBatchInternal::ByteSize(first->batch);
// Allow the group to grow up to a maximum... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0xc8, %rdi
callq 0x17920
movq -0x80(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x18f70
xorb $-0x1, %al
testb $0x1, %al
jne 0x1476f
jmp 0x14771
jmp 0x14790
leaq 0x... | /CDDSCLab[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::GetApproximateSizes(leveldb::Range const*, int, unsigned long*) | void DBImpl::GetApproximateSizes(const Range* range, int n, uint64_t* sizes) {
// TODO(opt): better implementation
MutexLock l(&mutex_);
Version* v = versions_->current();
v->Ref();
for (int i = 0; i < n; i++) {
// Convert user_key into a corresponding internal key.
InternalKey k1(range[i].start, kMa... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
addq $0xc8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x18300
movq -0xa0(%rbp), %rax
movq 0x228(%rax), %rdi
callq 0x18200
movq %rax, -0x98(%rbp)
jmp... | /CDDSCLab[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::LoadRange(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>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | Status DBImpl::LoadRange(const std::string& fname,
std::string* start,
std::string* end){
Status s;
uint64_t file_size;
RandomAccessFile* file = nullptr;
Table* table = nullptr;
s = env_->GetFileSize(fname, &file_size);
if (s.ok()) {
s = env_->NewRandomAccessFile(... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x198(%rbp)
movq %rdi, %rax
movq %rax, -0x190(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x188(%rbp)
movb $0x0, -0x29(%rbp)
cal... | /CDDSCLab[P]leveldb/db/db_impl.cc |
leveldb::VersionEdit::AddFile(int, unsigned long, unsigned long, leveldb::InternalKey const&, leveldb::InternalKey const&) | void AddFile(int level, uint64_t file, uint64_t file_size,
const InternalKey& smallest, const InternalKey& largest) {
FileMetaData f;
f.number = file;
f.file_size = file_size;
f.smallest = smallest;
f.largest = largest;
new_files_.push_back(std::make_pair(level, f));
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x17f50
movq -0x18(%rbp), %rax
movq %rax,... | /CDDSCLab[P]leveldb/db/version_edit.h |
leveldb::DBImpl::CompactionState::CompactionState(leveldb::Compaction*) | explicit CompactionState(Compaction* c)
: compaction(c),
smallest_snapshot(0),
outfile(nullptr),
builder(nullptr),
total_bytes(0) {} | 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), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
callq 0x1cb10
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
addq... | /CDDSCLab[P]leveldb/db/db_impl.cc |
leveldb::SnapshotList::Delete(leveldb::SnapshotImpl const*) | void Delete(const SnapshotImpl* snapshot) {
#if !defined(NDEBUG)
assert(snapshot->list_ == this);
#endif // !defined(NDEBUG)
snapshot->prev_->next_ = snapshot->next_;
snapshot->next_->prev_ = snapshot->prev_;
delete snapshot;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, 0x20(%rax)
jne 0x18d20
jmp 0x18d3f
leaq 0x37603(%rip), %rdi # 0x5032a
leaq 0x374ca(%rip), %rsi # 0x501f8
movl $0x51, %edx
leaq 0x37608(%rip), %rcx # 0x50342
callq ... | /CDDSCLab[P]leveldb/db/snapshot.h |
leveldb::(anonymous namespace)::DBIter::FindNextUserEntry(bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | void DBIter::FindNextUserEntry(bool skipping, std::string* skip) {
// Loop until we hit an acceptable entry to yield
assert(iter_->Valid());
assert(direction_ == kForward);
do {
ParsedInternalKey ikey;
if (ParseKey(&ikey) && ikey.sequence <= sequence_) {
switch (ikey.type) {
case kTypeDele... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x219c0
jmp 0x219c2
jmp 0x219e1
leaq 0x2eab4(%rip), %rdi ... | /CDDSCLab[P]leveldb/db/db_iter.cc |
leveldb::InternalKey::DebugString[abi:cxx11]() const | std::string InternalKey::DebugString() const {
ParsedInternalKey parsed;
if (ParseInternalKey(rep_, &parsed)) {
return parsed.DebugString();
}
std::ostringstream ss;
ss << "(bad)" << EscapeString(rep_);
return ss.str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x210(%rbp)
movq %rdi, %rax
movq %rax, -0x208(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x200(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x18960
movq -0x200(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x8b... | /CDDSCLab[P]leveldb/db/dbformat.cc |
leveldb::LookupKey::LookupKey(leveldb::Slice const&, unsigned long) | LookupKey::LookupKey(const Slice& user_key, SequenceNumber s) {
size_t usize = user_key.size();
size_t needed = usize + 13; // A conservative estimate
char* dst;
if (needed <= sizeof(space_)) {
dst = space_;
} else {
dst = new char[needed];
}
start_ = dst;
dst = EncodeVarint32(dst, usize + 8);
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc050
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0xd, %rax
movq %rax, -0x28(%rbp)
cmpq $0xc8, -0x28(%rbp)
ja 0x22c2d
movq -0... | /CDDSCLab[P]leveldb/db/dbformat.cc |
leveldb::ParseFileName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long*, leveldb::FileType*) | bool ParseFileName(const std::string& filename, uint64_t* number,
FileType* type) {
Slice rest(filename);
if (rest == "CURRENT") {
*number = 0;
*type = kCurrentFile;
} else if (rest == "LOCK") {
*number = 0;
*type = kDBLockFile;
} else if (rest == "LOG" || rest == "LOG.old") {... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x8b70
leaq -0x40(%rbp), %rdi
leaq 0x2d9a1(%rip), %rsi # 0x50b10
callq 0xbfc0
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x19230
testb $0x1, %... | /CDDSCLab[P]leveldb/db/filename.cc |
leveldb::log::Reader::ReadRecord(leveldb::Slice*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool Reader::ReadRecord(Slice* record, std::string* scratch) {
if (last_record_offset_ < initial_offset_) {
if (!SkipToInitialBlock()) {
return false;
}
}
scratch->clear();
record->clear();
bool in_fragmented_record = false;
// Record offset of the logical record that we're reading
// 0 is ... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movq 0x38(%rcx), %rax
cmpq 0x48(%rcx), %rax
jae 0x23a97
movq -0x98(%rbp), %rdi
callq 0x238e0
testb $0x1, %al
jne 0x23a95
movb $0x0, -0x1(%rbp)
jmp 0x23e4e
jmp 0x... | /CDDSCLab[P]leveldb/db/log_reader.cc |
leveldb::log::Writer::EmitPhysicalRecord(leveldb::log::RecordType, char const*, unsigned long) | Status Writer::EmitPhysicalRecord(RecordType t, const char* ptr,
size_t length) {
assert(length <= 0xffff); // Must fit in two bytes
assert(block_offset_ + kHeaderSize + length <= kBlockSize);
// Format the header
char buf[kHeaderSize];
buf[4] = static_cast<char>(length & 0... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0xffff, -0x28(%rbp) # imm = 0xFFFF
ja 0x24713
... | /CDDSCLab[P]leveldb/db/log_writer.cc |
leveldb::SkipList<char const*, leveldb::MemTable::KeyComparator>::SkipList(leveldb::MemTable::KeyComparator, leveldb::Arena*) | SkipList<Key, Comparator>::SkipList(Comparator cmp, Arena* arena)
: compare_(cmp),
arena_(arena),
head_(NewNode(0 /* any key will do */, kMaxHeight)),
max_height_(1),
rnd_(0xdeadbeef) {
for (int i = 0; i < kMaxHeight; i++) {
head_->SetNext(i, nullptr);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x25030
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x10(%rdi)
movq %rdi, %rax
addq $0x18, %rax
movq %rax... | /CDDSCLab[P]leveldb/db/skiplist.h |
leveldb::Arena::Allocate(unsigned long) | inline char* Arena::Allocate(size_t bytes) {
// The semantics of what to return are a bit messy if we allow
// 0-byte allocations, so we disallow them here (we don't need
// them for our internal use).
assert(bytes > 0);
if (bytes <= alloc_bytes_remaining_) {
char* result = alloc_ptr_;
alloc_ptr_ += b... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x252c1
jmp 0x252e0
leaq 0x2bfc2(%rip), %rdi # 0x5128a
leaq 0x2bfc5(%rip), %rsi # 0x51294
movl $0x3b, %edx
leaq 0x2c010(%rip), %rcx # 0x512eb
cal... | /CDDSCLab[P]leveldb/util/arena.h |
leveldb::(anonymous namespace)::Repairer::ScanTable(unsigned long) | void ScanTable(uint64_t number) {
TableInfo t;
t.meta.number = number;
std::string fname = TableFileName(dbname_, number);
Status status = env_->GetFileSize(fname, &t.meta.file_size);
if (!status.ok()) {
// Try alternate file name.
fname = SSTTableFileName(dbname_, number);
Status ... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x238(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x288b0
movq -0x238(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq ... | /CDDSCLab[P]leveldb/db/repair.cc |
leveldb::Version::PickLevelForMemTableOutput(leveldb::Slice const&, leveldb::Slice const&) | int Version::PickLevelForMemTableOutput(const Slice& smallest_user_key,
const Slice& largest_user_key) {
int level = 0;
if (!OverlapInLevel(0, &smallest_user_key, &largest_user_key)) {
// Push to next level if there is no overlap in next level,
// and the #bytes overl... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %esi, %esi
callq 0x2dea0
testb $0x1, %al
jne 0x2e0bd
movq -0x10(%rbp), %rsi
leaq -0x40(%r... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::VersionSet::WriteSnapshot(leveldb::log::Writer*) | Status VersionSet::WriteSnapshot(log::Writer* log) {
// TODO: Break up into multiple records to reduce memory usage on recovery?
// Save metadata
VersionEdit edit;
edit.SetComparatorName(icmp_.user_comparator()->Name());
// Save compaction pointers
for (int level = 0; level < config::kNumLevels; level++) ... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x180(%rbp)
movq %rdi, %rax
movq %rax, -0x178(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x17700
movq -0x170(%rbp), %rdi
addq $0x38... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::MaxBytesForLevel(leveldb::Options const*, int) | static double MaxBytesForLevel(const Options* options, int level) {
// Note: the result for level zero is not really used since we set
// the level-0 compaction threshold based on number of files.
// Result for both level-0 and level-1
double result = 10. * 1048576.0;
while (level > 1) {
result *= 10;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd 0x2157d(%rip), %xmm0 # 0x51bc0
movsd %xmm0, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0x3066b
movsd 0x21572(%rip), %xmm0 # 0x51bc8
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::VersionSet::CompactRange(int, leveldb::InternalKey const*, leveldb::InternalKey const*) | Compaction* VersionSet::CompactRange(int level, const InternalKey* begin,
const InternalKey* end) {
std::vector<FileMetaData*> inputs;
current_->GetOverlappingInputs(level, begin, end, &inputs);
if (inputs.empty()) {
return nullptr;
}
// Avoid compacting too much in o... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x32b70
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %r8
movq 0x168(%rax), %rdi
movl -0x14... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::Compaction::IsTrivialMove() const | bool Compaction::IsTrivialMove() const {
const VersionSet* vset = input_version_->vset_;
// Avoid a move if there is lots of overlapping grandparent data.
// Otherwise, the move could create a parent file that will require
// a very expensive merge later on.
return (num_input_files(0) == 1 && num_input_files(... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq 0x10(%rdi), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
xorl %esi, %esi
callq 0x185c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, -0x11(%rbp)
jne 0x3251d
movq -0x20(%rbp), %rdi
movl $0x1, ... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::Compaction::ShouldStopBefore(leveldb::Slice const&) | bool Compaction::ShouldStopBefore(const Slice& internal_key) {
const VersionSet* vset = input_version_->vset_;
// Scan to find earliest grandparent file that contains key.
const InternalKeyComparator* icmp = &vset->icmp_;
while (grandparent_index_ < grandparents_.size() &&
icmp->Compare(internal_key,
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movq 0x108(%rdi), %rax
movq %rax, -... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::NewMergingIterator(leveldb::Comparator const*, leveldb::Iterator**, int) | Iterator* NewMergingIterator(const Comparator* comparator, Iterator** children,
int n) {
assert(n >= 0);
if (n == 0) {
return NewEmptyIterator();
} else if (n == 1) {
return children[0];
} else {
return new MergingIterator(comparator, children, n);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x39d8b
jmp 0x39daa
leaq 0x171c9(%rip), %rdi # 0x50f5b
leaq 0x18baf(%rip), %rsi # 0x52948
movl $0xb5, %edx
leaq 0x18bfd(%rip), %rcx # 0x529a2
callq 0x7300
cmpl $0x0, -0x... | /CDDSCLab[P]leveldb/table/merger.cc |
leveldb::(anonymous namespace)::MergingIterator::Prev() | void Prev() override {
assert(Valid());
// Ensure that all children are positioned before key().
// If we are moving in the reverse direction, it is already
// true for all of the non-current_ children since current_ is
// the largest child and key() == current_->key(). Otherwise,
// we explic... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x3a390
jmp 0x3a392
jmp 0x3a3b1
leaq 0x160eb(%rip), %rdi # 0x50484
leaq 0x185a8(%rip), %rsi # 0x52948
movl $0x52, %edx
leaq 0x187ce(%rip), %rcx ... | /CDDSCLab[P]leveldb/table/merger.cc |
leveldb::TableBuilder::Flush() | void TableBuilder::Flush() {
Rep* r = rep_;
assert(!r->closed);
if (!ok()) return;
if (r->data_block.empty()) return;
assert(!r->pending_index_entry);
WriteBlock(&r->data_block, &r->pending_handle);
if (ok()) {
r->pending_index_entry = true;
r->status = r->file->Flush();
}
if (r->filter_block ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x1d0(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3b16d
jmp 0x3b16f
jmp 0x3b18e
leaq 0x17c4d(%rip), %rdi # 0x52dc3
leaq 0x17b95(%ri... | /CDDSCLab[P]leveldb/table/table_builder.cc |
leveldb::TableBuilder::WriteBlock(leveldb::BlockBuilder*, leveldb::BlockHandle*) | void TableBuilder::WriteBlock(BlockBuilder* block, BlockHandle* handle) {
// File format contains a sequence of blocks where each block has:
// block_data: uint8[n]
// type: uint8
// crc: uint32
assert(ok());
Rep* r = rep_;
Slice raw = block->Finish();
Slice block_contents;
CompressionType t... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3bf00
testb $0x1, %al
jne 0x3b2ba
jmp 0x3b2bc
jmp 0x3b2db
leaq 0x13dd6(%rip), %rdi # 0x4f099
leaq 0x17a48(%rip), %rsi # 0x52d12
movl $0x92, %edx
le... | /CDDSCLab[P]leveldb/table/table_builder.cc |
leveldb::TableBuilder::Rep::Rep(leveldb::Options const&, leveldb::WritableFile*) | Rep(const Options& opt, WritableFile* f)
: options(opt),
index_block_options(opt),
file(f),
offset(0),
data_block(&options),
index_block(&index_block_options),
num_entries(0),
closed(false),
filter_block(opt.filter_policy == nullptr
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rax
movups 0x50(%rax), %xmm0
movups %xmm0, 0x50(%rdi)
movups 0x40(%rax), %xmm0
movups %xmm0, 0x40(%rdi)
movups (%rax), %xmm0
movups 0x10(%rax), ... | /CDDSCLab[P]leveldb/table/table_builder.cc |
leveldb::(anonymous namespace)::TwoLevelIterator::SkipEmptyDataBlocksForward() | void TwoLevelIterator::SkipEmptyDataBlocksForward() {
while (data_iter_.iter() == nullptr || !data_iter_.Valid()) {
// Move to next block
if (!index_iter_.Valid()) {
SetDataIterator(nullptr);
return;
}
index_iter_.Next();
InitDataBlock();
if (data_iter_.iter() != nullptr) data_iter... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x3e600
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x11(%rbp)
je 0x3e3c1
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x3a990
xorb $-0x1, %al
movb ... | /CDDSCLab[P]leveldb/table/two_level_iterator.cc |
leveldb::(anonymous namespace)::LRUCache::Insert(leveldb::Slice const&, unsigned int, void*, unsigned long, void (*)(leveldb::Slice const&, void*)) | Cache::Handle* LRUCache::Insert(const Slice& key, uint32_t hash, void* value,
size_t charge,
void (*deleter)(const Slice& key,
void* value)) {
MutexLock l(&mutex_);
LRUHandle* e =
reinterpret_cast<... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x78(%rbp)
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0x18300
movq -0x10(%rbp), %rdi
callq 0xc050
movq %r... | /CDDSCLab[P]leveldb/util/cache.cc |
leveldb::GetVarint64(leveldb::Slice*, unsigned long*) | bool GetVarint64(Slice* input, uint64_t* value) {
const char* p = input->data();
const char* limit = p + input->size();
const char* q = GetVarint64Ptr(p, limit, value);
if (q == nullptr) {
return false;
} else {
*input = Slice(q, limit - q);
return true;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc070
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc050
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(... | /CDDSCLab[P]leveldb/util/coding.cc |
leveldb::DoWriteStringToFile(leveldb::Env*, leveldb::Slice const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | static Status DoWriteStringToFile(Env* env, const Slice& data,
const std::string& fname, bool should_sync) {
WritableFile* file;
Status s = env->NewWritableFile(fname, &file);
if (!s.ok()) {
return s;
}
s = file->Append(data);
if (s.ok() && should_sync) {
s = file->... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x78(%rbp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq... | /CDDSCLab[P]leveldb/util/env.cc |
leveldb::Block::NewIterator(leveldb::Comparator const*) | Iterator* Block::NewIterator(const Comparator* comparator) {
if (size_ < sizeof(uint32_t)) {
return NewErrorIterator(Status::Corruption("bad block contents"));
}
const uint32_t num_restarts = NumRestarts();
if (num_restarts == 0) {
return NewEmptyIterator();
} else {
return new Iter(comparator, da... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x4, 0x8(%rax)
jae 0x4ba64
leaq 0x9d16(%rip), %rsi # 0x5570f
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xbfc0
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0... | /CDDSCLab[P]leveldb/table/block.cc |
main | int main(int argc, char **argv) {
// Parse args
const char *input_basename = nullptr;
const char *output_path = nullptr;
for (int i = 1; i < argc; i++) {
// Basename?
if (input_basename == nullptr) {
input_basename = argv[i];
continue;
}
// Output dir?
if (output_path == nullptr... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movslq %edi, %rcx
pushq $0x1
popq %rdx
xorl %eax, %eax
xorl %r14d, %r14d
cmpq %rcx, %rdx
jge 0x449f
testq %rax, %rax
je 0x4496
testq %r14, %r14
jne 0x45f4
movq (%rsi,%rdx,8), %r14
jmp 0x449a
movq (%rsi,%rdx,8), %rax
incq ... | /rschlaikjer[P]mangetsu/src/tools/hfa_extract.cpp |
mg::data::MappedHfa::parse(std::shared_ptr<mg::fs::MappedFile>) | std::unique_ptr<MappedHfa>
MappedHfa::parse(std::shared_ptr<mg::fs::MappedFile> backing_data) {
// Check file larger enough to have a header
if ((size_t)backing_data->size() < sizeof(Hfa::FileHeader)) {
fprintf(stderr, "File too short to read header\n");
return nullptr;
}
// Check magic is correct
Hf... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
cmpq $0xf, 0x8(%rax)
jbe 0x4e48
movq %rsi, %r14
movq (%rax), %r15
movups (%r15), %xmm0
leaq -0x90(%rbp), %rdi
movaps %xmm0, (%rdi)
leaq 0x1463(%rip), %rsi # 0x61e3
pushq $0xc
popq %r... | /rschlaikjer[P]mangetsu/src/data/hfa.cpp |
mg::fs::read_file(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool read_file(const char *path, std::string &out) {
// Open file
const int fd = open(path, O_RDONLY);
if (fd == -1) {
fprintf(stderr, "Failed to open '%s' - %s\n", path, strerror(errno));
return false;
}
std::shared_ptr<void> _defer_close_fd(nullptr, [=](...) { close(fd); });
static const size_t r... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp # imm = 0x1028
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
xorl %eax, %eax
callq 0x4140
cmpl $-0x1, %eax
je 0x534e
movl %eax, %r12d
andq $0x0, -0x48(%rbp)
pushq $0x20
popq %rdi
callq 0x4180
leaq -0x... | /rschlaikjer[P]mangetsu/src/util/fs.cpp |
mg::fs::write_file(char const*, std::basic_string_view<char, std::char_traits<char>> const&) | bool write_file(const char *path, const std::string_view &data) {
// Open file
const int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0644);
if (fd == -1) {
fprintf(stderr, "Failed to open '%s' - %s\n", path, strerror(errno));
return false;
}
std::shared_ptr<void> _defer_close_fd(nullptr, [=](...) { cl... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x242, %esi # imm = 0x242
movl $0x1a4, %edx # imm = 0x1A4
xorl %eax, %eax
callq 0x4140
cmpl $-0x1, %eax
je 0x54db
movl %eax, %r12d
andq $0x0, -0x40(%rbp)
pushq $... | /rschlaikjer[P]mangetsu/src/util/fs.cpp |
cxxflags[abi:cxx11](bool) | std::string cxxflags(bool internal = false) {
std::string cppflags;
if (internal) {
cppflags += "-I../include -I../../include "; // bjam, cmake
static std::unordered_map<std::string, std::string> flags = {
{"msvc14", "/std:c++14"}, {"clang14", "-std=c++1y"}, {"gcc14", "-std=c++1y"},
{"... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %esi, %esi
je 0xa79e
leaq 0x10a22(%rip), %rsi # 0x1b10e
movq %rbx, %rdi
callq 0x5570
movb 0x22046(%rip), %al # 0x2c740
... | /boost-ext[P]di/test/common/utils.hpp |
(anonymous namespace)::compail_fail(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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<char>>>> cons... | auto compail_fail(int id, const std::string& defines, const std::vector<std::string>& errors, const std::string& code) {
std::stringstream command;
{
file<> source_code{std::string{"error"} + std::to_string(id) + ".cpp"};
source_code << "#include <boost/di.hpp>" << std::endl;
source_code << "namespace d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5e8, %rsp # imm = 0x5E8
movq %rcx, %r15
movq %rdx, 0x40(%rsp)
movq %rsi, %r14
movl %edi, %ebp
leaq 0x460(%rsp), %rdi
callq 0x5260
leaq 0x107a2(%rip), %rsi # 0x1b294
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0x5140
leaq 0x20... | /boost-ext[P]di/test/ft/di_errors.cpp |
auto (anonymous namespace)::errors<char [25], char [54]>(char const (&) [25], char const (&) [54]) | auto errors(const TArgs&... args) {
return std::vector<std::string>{(".*" + std::string{args} + ".*")...};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
leaq 0x1074f(%rip), %rsi # 0x1be67
leaq 0xa8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x5140
leaq 0x107fc(%rip), %rsi # 0x1bf30
leaq 0x48(%rsp), %rdi
movq %rbx, %rdx
callq 0x1a1bf
leaq 0x107e8(%rip), %rdx # 0x1bf30
le... | /boost-ext[P]di/test/ft/di_errors.cpp |
auto (anonymous namespace)::errors<char [25], char [41]>(char const (&) [25], char const (&) [41]) | auto errors(const TArgs&... args) {
return std::vector<std::string>{(".*" + std::string{args} + ".*")...};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
leaq 0xff1c(%rip), %rsi # 0x1be67
leaq 0xa8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x5140
leaq 0xffc9(%rip), %rsi # 0x1bf30
leaq 0x48(%rsp), %rdi
movq %rbx, %rdx
callq 0x1a1bf
leaq 0xffb5(%rip), %rdx # 0x1bf30
le... | /boost-ext[P]di/test/ft/di_errors.cpp |
auto (anonymous namespace)::errors<char [25], char [27], char [11], char [27]>(char const (&) [25], char const (&) [27], char const (&) [11], char const (&) [27]) | auto errors(const TArgs&... args) {
return std::vector<std::string>{(".*" + std::string{args} + ".*")...};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, %r14
leaq 0xfbd4(%rip), %rsi # 0x1be67
leaq 0xe8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x5140
leaq 0xfc81(%rip), %rsi # 0x1bf30
leaq 0xc8(%rsp), %rdi
movq %rbx, %rdx
callq 0x1a1bf
leaq 0xfc6a(%ri... | /boost-ext[P]di/test/ft/di_errors.cpp |
auto (anonymous namespace)::errors<char [38], char [9], char [4], char [7], char [94]>(char const (&) [38], char const (&) [9], char const (&) [4], char const (&) [7], char const (&) [94]) | auto errors(const TArgs&... args) {
return std::vector<std::string>{(".*" + std::string{args} + ".*")...};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, %r14
leaq 0x11660(%rip), %rsi # 0x1e200
leaq 0x128(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x5140
leaq 0xf374(%rip), %rsi # 0x1bf30
leaq 0x108(%rsp), %rdi
movq %rbx, %rdx
callq 0x1a1bf
leaq 0xf35d(%... | /boost-ext[P]di/test/ft/di_errors.cpp |
mbedtls_asn1_get_len | int mbedtls_asn1_get_len( unsigned char **p,
const unsigned char *end,
size_t *len )
{
if( ( end - *p ) < 1 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
if( ( **p & 0x80 ) == 0 )
*len = *(*p)++;
else
{
switch( **p & 0x7F )
{
case ... | movq (%rdi), %rcx
movq %rsi, %r8
subq %rcx, %r8
pushq $-0x60
popq %rax
testq %r8, %r8
jle 0x34bd
movzbl (%rcx), %r9d
testb %r9b, %r9b
js 0x34be
leaq 0x1(%rcx), %r8
movq %r8, (%rdi)
movzbl (%rcx), %eax
movq %rax, (%rdx)
subq %r8, %rsi
xorl %ecx, %ecx
cmpq %rsi, %rax
pushq $-0x60
popq %rax
cmovbel %ecx, %eax
retq
andl $0... | /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mbedtls_asn1_get_tag | int mbedtls_asn1_get_tag( unsigned char **p,
const unsigned char *end,
size_t *len, int tag )
{
if( ( end - *p ) < 1 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
if( **p != tag )
return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
(*p)++;
return( mbedtls_asn1_g... | movq (%rdi), %rax
movq %rsi, %r8
subq %rax, %r8
testq %r8, %r8
jle 0x3579
movzbl (%rax), %r8d
cmpl %ecx, %r8d
jne 0x357d
incq %rax
movq %rax, (%rdi)
jmp 0x3488
pushq $-0x60
jmp 0x357f
pushq $-0x62
popq %rax
retq
| /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mbedtls_asn1_write_mpi | int mbedtls_asn1_write_mpi( unsigned char **p, unsigned char *start, const mbedtls_mpi *X )
{
int ret;
size_t len = 0;
// Write the MPI
//
len = mbedtls_mpi_size( X );
if( *p < start || (size_t)( *p - start ) < len )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
(*p) -= len;
MBEDT... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rdi
callq 0x4628
movq %rax, %r15
movq (%r14), %rsi
pushq $-0x6c
popq %rbx
movq %rsi, %rax
subq %r12, %rax
jb 0x3b64
cmpq %r15, %rax
jb 0x3b64
subq %r15, %rsi
movq %rsi, (%r14)
movq %r13, %rdi
movq %r15, %r... | /Dragonchang[P]https_client/mbedtls/library/asn1write.c |
mbedtls_asn1_write_null | int mbedtls_asn1_write_len( unsigned char **p, unsigned char *start, size_t len )
{
if( len < 0x80 )
{
if( *p - start < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = (unsigned char) len;
return( 1 );
}
if( len <= 0xFF )
{
if( *p - start < 2 )
... | movq (%rdi), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
pushq $-0x6c
popq %rax
testq %rdx, %rdx
jle 0x3c07
leaq -0x1(%rcx), %rdx
movq %rdx, (%rdi)
movb $0x0, -0x1(%rcx)
movq (%rdi), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
testq %rdx, %rdx
jle 0x3c07
leaq -0x1(%rcx), %rax
movq %rax, (%rdi)
movb $0x5, -0x1(%rcx)
pushq $0x2
popq %... | /Dragonchang[P]https_client/mbedtls/library/asn1write.c |
mbedtls_asn1_write_algorithm_identifier | int mbedtls_asn1_write_algorithm_identifier( unsigned char **p, unsigned char *start,
const char *oid, size_t oid_len,
size_t par_len )
{
int ret;
size_t len = 0;
if( par_len == 0 )
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_wri... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
testq %r8, %r8
jne 0x3cbf
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3bcf
testl %eax, %eax
js 0x3d0e
movl %eax, %r14d
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0... | /Dragonchang[P]https_client/mbedtls/library/asn1write.c |
mbedtls_asn1_write_bitstring | int mbedtls_asn1_write_bitstring( unsigned char **p, unsigned char *start,
const unsigned char *buf, size_t bits )
{
int ret;
size_t len = 0, size;
size = ( bits / 8 ) + ( ( bits % 8 ) ? 1 : 0 );
// Calculate byte length
//
if( *p < start || (size_t)( *p - start ) < s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdi, %rbx
movq %rcx, %r12
shrq $0x3, %r12
movl %r13d, %eax
andl $0x7, %eax
cmpq $0x1, %rax
sbbq $-0x1, %r12
movq (%rdi), %rdi
pushq $-0x6c
popq %rbp
movq %rdi, %rax
subq %rsi, %rax
jb 0x3fb4
cmpq %r12, %rax
jbe 0x3fb4
mov... | /Dragonchang[P]https_client/mbedtls/library/asn1write.c |
mbedtls_mpi_free | void mbedtls_mpi_free( mbedtls_mpi *X )
{
if( X == NULL )
return;
if( X->p != NULL )
{
mbedtls_mpi_zeroize( X->p, X->n );
mbedtls_free( X->p );
}
X->s = 1;
X->n = 0;
X->p = NULL;
} | testq %rdi, %rdi
je 0x4199
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x418b
movq 0x8(%rbx), %rsi
callq 0x419a
movq 0x10(%rbx), %rdi
callq 0x2030
movl $0x1, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
popq %rbx
retq
| /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_shrink | int mbedtls_mpi_shrink( mbedtls_mpi *X, size_t nblimbs )
{
mbedtls_mpi_uint *p;
size_t i;
/* Actually resize up in this case */
if( X->n <= nblimbs )
return( mbedtls_mpi_grow( X, nblimbs ) );
for( i = X->n - 1; i > 0; i-- )
if( X->p[i] != 0 )
break;
i++;
if( i ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpq %rsi, %r15
jbe 0x42bd
movq %r15, %rcx
movq %rcx, %rax
cmpq $0x1, %rcx
je 0x4267
movq 0x10(%r14), %rdx
leaq -0x1(%rax), %rcx
cmpq $0x0, -0x8(%rdx,%rax,8)
je 0x424e
cmpq %rbx, %rax
cmovaq %rax, %rbx
pushq $0x8... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_read_string | int mbedtls_mpi_read_string( mbedtls_mpi *X, int radix, const char *s )
{
int ret;
size_t i, j, slen, n;
mbedtls_mpi_uint d;
mbedtls_mpi T;
if( radix < 2 || radix > 16 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
mbedtls_mpi_init( &T );
slen = strlen( s );
if( radix == 16 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r13d
leal -0x11(%r13), %eax
pushq $-0x4
popq %rbx
cmpl $-0xf, %eax
jb 0x4735
movq %rdx, %r14
movq %rdi, %r15
movl $0x1, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movq %rdx, %rdi
callq 0x2080
movq %rax, %r12
cmpl ... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_sub_int | int mbedtls_mpi_sub_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
mbedtls_mpi _B;
mbedtls_mpi_uint p[1];
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
return( mbedtls_mpi_sub_mpi( X, A, &_B ) );
} | subq $0x28, %rsp
movq %rdx, %rax
negq %rax
cmovsq %rdx, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
sarq $0x3f, %rdx
orl $0x1, %edx
leaq 0x10(%rsp), %rax
movl %edx, (%rax)
movq $0x1, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x52c2
addq $0x28, %rsp
retq
| /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_shift_l | int mbedtls_mpi_shift_l( mbedtls_mpi *X, size_t count )
{
int ret;
size_t i, v0, t1;
mbedtls_mpi_uint r0 = 0, r1;
v0 = count / (biL );
t1 = count & (biL - 1);
i = mbedtls_mpi_bitlen( X ) + count;
if( X->n * biL < i )
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, BITS_TO_LIMBS( i ) ) );... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x45c3
addq %r14, %rax
movq 0x8(%rbx), %rcx
shlq $0x6, %rcx
cmpq %rax, %rcx
jae 0x4dde
movq %rax, %rsi
shrq $0x6, %rsi
andl $0x3f, %eax
cmpq $0x1, %rax
sbbq $-0x1, %rsi
movq %rbx, %rdi
callq 0x41af
testl %eax, %eax
jne 0x4e67
movq %r14, %rdi
shrq $0... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_shift_r | int mbedtls_mpi_shift_r( mbedtls_mpi *X, size_t count )
{
size_t i, v0, v1;
mbedtls_mpi_uint r0 = 0, r1;
v0 = count / biL;
v1 = count & (biL - 1);
if( v0 > X->n || ( v0 == X->n && v1 > 0 ) )
return mbedtls_mpi_lset( X, 0 );
/*
* shift by count / limb_size
*/
if( v0 > 0 ... | movq %rsi, %rcx
shrq $0x6, %rcx
movl %esi, %eax
andl $0x3f, %eax
movq 0x8(%rdi), %r8
cmpq %r8, %rcx
ja 0x4e93
setne %dl
testq %rax, %rax
sete %r9b
orb %dl, %r9b
jne 0x4e9a
xorl %esi, %esi
jmp 0x44a0
cmpq $0x40, %rsi
jb 0x4ee3
leaq (,%rcx,8), %rsi
xorl %edx, %edx
movq %r8, %r9
subq %rcx, %r9
cmpq %r9, %rdx
jae 0x4ede
mo... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_cmp_abs | int mbedtls_mpi_cmp_abs( const mbedtls_mpi *X, const mbedtls_mpi *Y )
{
size_t i, j;
for( i = X->n; i > 0; i-- )
if( X->p[i - 1] != 0 )
break;
for( j = Y->n; j > 0; j-- )
if( Y->p[j - 1] != 0 )
break;
if( i == 0 && j == 0 )
return( 0 );
if( i > j )... | movq 0x8(%rdi), %rax
movq %rax, %rcx
subq $0x1, %rax
jb 0x4f32
movq 0x10(%rdi), %rdx
cmpq $0x0, (%rdx,%rax,8)
je 0x4f1e
movq 0x8(%rsi), %rax
movq %rax, %r8
subq $0x1, %rax
jb 0x4f4a
movq 0x10(%rsi), %rdx
cmpq $0x0, (%rdx,%rax,8)
je 0x4f36
xorl %eax, %eax
movq %r8, %rdx
orq %rcx, %rdx
je 0x4f82
pushq $0x1
popq %rdx
cmpq... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_add_abs | int mbedtls_mpi_add_abs( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret;
size_t i, j;
mbedtls_mpi_uint *o, *p, c, tmp;
if( X == B )
{
const mbedtls_mpi *T = A; A = X; B = T;
}
if( X != A )
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, A ) );
/*
* X... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
cmpq %rdx, %rdi
cmoveq %rsi, %r15
sete %al
cmpq %rdi, %rsi
sete %cl
orb %al, %cl
jne 0x5083
movq %rbx, %rdi
callq 0x42de
testl %eax, %eax
jne 0x513e
movl $0x1, (%rbx)
movq 0x8(%r15), %r14
leaq (,%r14,8), %r12
negq %r12
movq %r14, %ra... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mpi_sub_hlp | static void mpi_sub_hlp( size_t n, mbedtls_mpi_uint *s, mbedtls_mpi_uint *d )
{
size_t i;
mbedtls_mpi_uint c, z;
for( i = c = 0; i < n; i++, s++, d++ )
{
z = ( *d < c ); *d -= c;
c = ( *d < *s ) + z; *d -= *s;
}
while( c != 0 )
{
z = ( *d < c ); *d -= c;
... | xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rax, %rdi
je 0x524e
movq (%rdx), %r8
movq %r8, %r9
subq %rcx, %r9
movq %r9, (%rdx)
xorl %r10d, %r10d
subq (%rsi,%rax,8), %r9
setb %r10b
cmpq %rcx, %r8
adcq $0x0, %r10
movq %r9, (%rdx)
incq %rax
addq $0x8, %rdx
movq %r10, %rcx
jmp 0x520d
xorl %eax, %eax
subq %rcx, (%rdx)
setb %al
ad... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_add_mpi | int mbedtls_mpi_add_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret, s = A->s;
if( A->s * B->s < 0 )
{
if( mbedtls_mpi_cmp_abs( A, B ) >= 0 )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, A, B ) );
X->s = s;
}
else
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %ebp
movl (%rdx), %eax
imull %ebp, %eax
testl %eax, %eax
js 0x527f
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5050
jmp 0x529c
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f1a
movq %rbx, %rdi
test... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_is_prime | int mbedtls_mpi_is_prime( const mbedtls_mpi *X,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
mbedtls_mpi XX;
XX.s = 1;
XX.n = X->n;
XX.p = X->p;
if( mbedtls_mpi_cmp_int( &XX, 0 ) == 0 ||
mbedtls_mpi_cmp_int( &XX, 1 ) == 0 )... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %rax
movl $0x1, (%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x5013
pushq $-0xe
popq %rbp
testl %eax, %eax
je 0x6d39
leaq 0x8(%rsp), %rd... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mpi_check_small_factors | static int mpi_check_small_factors( const mbedtls_mpi *X )
{
int ret = 0;
size_t i;
mbedtls_mpi_uint r;
if( ( X->p[0] & 1 ) == 0 )
return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
for( i = 0; small_prime[i] > 0; i++ )
{
if( mbedtls_mpi_cmp_int( X, small_prime[i] ) <= 0 )
r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
pushq $-0xe
popq %rbx
testb $0x1, (%rax)
je 0x6db2
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x1dc8(%rip), %rbp # 0x8b30
movq %rsp, %r15
cmpq $0x29c, %r13 # imm = 0x29C
je 0x6da7
movl (%r13,%rbp), %r12d
movq ... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
binlog::detail::RecoverableVectorOutputStream::write(char const*, long) | RecoverableVectorOutputStream& write(const char* buffer, std::streamsize size)
{
std::uint64_t magic = 0;
if (_vector.capacity() < _vector.size() + std::size_t(size))
{
// vector will reallocate, clear the magic of the old buffer
// to avoid recovering invalid data
magic = clearMagic();
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
subq %rax, %rdi
movq %rcx, %r8
subq %rax, %r8
addq %rsi, %r8
cmpq %r8, %rdi
jae 0x4d95
movq (%rax), %r14
movq $0x0, (%rax)
movq 0x8(%rbx), %rsi
addq %rdx, %rcx
movq %rbx, %rdi
ca... | /erenon[P]binlog/include/binlog/detail/VectorOutputStream.hpp |
void mserialize::StructSerializer<binlog::ClockSync, std::integral_constant<unsigned long binlog::ClockSync::*, &binlog::ClockSync::clockValue>, std::integral_constant<unsigned long binlog::ClockSync::*, &binlog::ClockSync::clockFrequency>, std::integral_constant<unsigned long binlog::ClockSync::*, &binlog::ClockSync::... | static void serialize(const T& t, OutputStream& ostream)
{
using swallow = int[];
(void)swallow{1, (serialize_member(t, Members::value, ostream), int{})...};
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movl $0x8, %edx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x4d46
movq 0x8(%r14), %rax
movq %rax, (%r15)
leaq 0x8(%rsp), %r15
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d46... | /erenon[P]binlog/include/mserialize/StructSerializer.hpp |
binlog::Session::createChannel(unsigned long, binlog::WriterProp) | inline std::shared_ptr<Session::Channel> Session::createChannel(std::size_t queueCapacity, WriterProp writerProp)
{
std::lock_guard<std::mutex> lock(_mutex);
_channels.push_back(std::make_shared<Channel>(*this, queueCapacity, std::move(writerProp)));
return _channels.back();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x18(%rsp)
movq %rsi, %rdi
callq 0x3300
testl %eax, %eax
jne 0x519d
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rdx
leaq 0x18(%rsp), %r8
movq %rbx, %rcx
movq %r15, %r9
callq... | /erenon[P]binlog/include/binlog/Session.hpp |
unsigned long binlog::serializeSizePrefixedTagged<binlog::EventSource, binlog::detail::RecoverableVectorOutputStream>(binlog::EventSource const&, binlog::detail::RecoverableVectorOutputStream&) | std::size_t serializeSizePrefixedTagged(const Entry& entry, OutputStream& out)
{
const std::uint64_t tag = Entry::Tag;
const std::uint32_t size = std::uint32_t(mserialize::serialized_size(entry) + sizeof(tag));
mserialize::serialize(size, out);
mserialize::serialize(tag, out);
mserialize::serialize(entry, out... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x5626
movq %rax, %r14
addl $0x8, %r14d
leaq 0x4(%rsp), %rsi
movl %r14d, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x4d46
leaq 0x8(%rsp), %rsi
movq $-0x1, (%rsi)
movl $0x8, %edx
movq %rbx, %rdi
callq 0x4d46
movq %r15, %rdi
movq %... | /erenon[P]binlog/include/binlog/Entries.hpp |
mserialize::StructSerializer<binlog::EventSource, std::integral_constant<unsigned long binlog::EventSource::*, &binlog::EventSource::id>, std::integral_constant<binlog::Severity binlog::EventSource::*, &binlog::EventSource::severity>, std::integral_constant<std::__cxx11::basic_string<char, std::char_traits<char>, std::... | static std::size_t serialized_size(const T& t)
{
const std::size_t field_sizes[] = {0, serialized_size_member(t, Members::value)...};
std::size_t result = 0;
for (auto s : field_sizes) { result += s; }
return result;
} | movq $0x0, -0x48(%rsp)
movl $0x8, %eax
movq %rax, -0x40(%rsp)
movq $0x2, -0x38(%rsp)
movq 0x18(%rdi), %rcx
addq $0x4, %rcx
movq %rcx, -0x30(%rsp)
movq 0x38(%rdi), %rcx
addq $0x4, %rcx
movq %rcx, -0x28(%rsp)
movq 0x58(%rdi), %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rsp)
movq %rax, -0x18(%rsp)
movq 0x80(%rdi), %rax
addq $0... | /erenon[P]binlog/include/mserialize/StructSerializer.hpp |
auto mserialize::cx_strcat<1ul, 1ul>(mserialize::cx_string<1ul> const&&, mserialize::cx_string<1ul> const&&) | constexpr auto cx_strcat(const cx_string<N>&&... strings)
{
char buffer[detail::sum<N...>()+1] = {0};
const char* data[] = {"", strings.data()...};
const std::size_t size[] = {0, strings.size()...};
char* out = buffer;
for (std::size_t i = 1; i <= sizeof...(N); ++i)
{
for (std::size_t s = 0; s < size[i... | leaq -0x3c(%rsp), %rax
movb $0x0, 0x2(%rax)
movw $0x0, (%rax)
movq %rdi, -0x10(%rsp)
movq %rsi, -0x8(%rsp)
movl $0x1, %ecx
movq %rcx, -0x30(%rsp)
movq %rcx, -0x28(%rsp)
cmpq $0x0, -0x38(%rsp,%rcx,8)
je 0x579a
xorl %edx, %edx
movq -0x18(%rsp,%rcx,8), %rsi
movb (%rsi,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq -0x3... | /erenon[P]binlog/include/mserialize/cx_string.hpp |
binlog::detail::QueueWriter::maximizeWriteCapacity() | std::size_t maximizeWriteCapacity()
{
const std::size_t w = _queue->writeIndex.load(std::memory_order_relaxed);
const std::size_t r = _queue->readIndex.load(std::memory_order_acquire);
if (w < r) // [####W.....R###E..]
{
_writePos = buffer() + w;
_writeEnd = buffer() + r - 1;
}
el... | movq (%rdi), %rax
movq (%rax), %rcx
movq 0x20(%rax), %rdx
movq (%rdi), %rsi
cmpq %rdx, %rcx
jae 0x5d17
movq 0x18(%rsi), %rax
addq %rax, %rcx
movq %rcx, 0x8(%rdi)
addq %rdx, %rax
decq %rax
jmp 0x5d4b
movq 0x10(%rsi), %rax
movq %rax, %r8
subq %rcx, %r8
decq %rdx
cmpq %rdx, %r8
jge 0x5d3d
movq %rcx, 0x8(%rsi)
movq 0x18(%r... | /erenon[P]binlog/include/binlog/detail/QueueWriter.hpp |
binlog::Session::ConsumeResult binlog::Session::consume<MultiOutputStream>(MultiOutputStream&) | Session::ConsumeResult Session::consume(OutputStream& out)
{
// This lock:
// - Ensures only a single consumer is running at a time
// - Ensures safe read of _channels
// - Ensures safe read of Channel::writerProp (written by setChannelWriterName)
// - Ensures safe read of _sources
// - Ensures no new ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r13
movq %rsi, %rdi
callq 0x3300
testl %eax, %eax
jne 0x60d6
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
cmpb $0x1, 0x8a(%rbx)
jne 0x5f10
movq 0x40(%rbx), %rsi
movq 0... | /erenon[P]binlog/include/binlog/Session.hpp |
unsigned long binlog::Session::consumeSpecialEntry<binlog::WriterProp, MultiOutputStream>(binlog::WriterProp const&, MultiOutputStream&) | std::size_t Session::consumeSpecialEntry(const Entry& entry, OutputStream& out)
{
// Write entry to `_specialEntryBuffer` first, only then to `out` in one go.
// This makes OutputStream logic simpler (if it parses the stream),
// as it does not have to deal with partial entries.
// (serializeSizePrefixedTagged ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x90(%rdi), %rsi
movq 0x90(%rdi), %rcx
cmpq %rcx, 0x98(%rdi)
je 0x61e2
movq %rcx, 0x98(%r14)
movq %rax, %rdi
callq 0x6b70
movq %rax, %r15
movq 0x90(%r14), %rsi
movq 0x98(%r14), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x610a
movq %r... | /erenon[P]binlog/include/binlog/Session.hpp |
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.