name string | code string | asm string | file string |
|---|---|---|---|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [22], char const*>(char const (&) [22], char const*&&) | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x10235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6580
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1c65f
mov... | /pantor[P]inja/third_party/include/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::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::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allo... | static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
{
static const std::array<std::uint8_t, 400> utf8d =
{
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
... | movl %edx, %ecx
leaq 0x17703(%rip), %rax # 0x386c6
movzbl (%rcx,%rax), %ecx
cmpb $0x0, (%rdi)
je 0x20fdd
andb $0x3f, %dl
movzbl %dl, %r8d
movl (%rsi), %edx
shll $0x6, %edx
orl %r8d, %edx
jmp 0x20fec
movl $0xff, %r8d
shrl %cl, %r8d
movzbl %dl, %edx
andl %r8d, %edx
movl %edx, (%rsi)
movzbl (%rdi), %edx
shll $0x4, %ed... | /pantor[P]inja/third_party/include/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(char*, int, unsigned long, unsigned long, unsigned long, unsigned long) | inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
std::uint64_t rest, std::uint64_t ten_k)
{
JSON_ASSERT(len >= 1);
JSON_ASSERT(dist <= delta);
JSON_ASSERT(rest <= delta);
JSON_ASSERT(ten_k > 0);
// <------------------------... | pushq %rax
testl %esi, %esi
jle 0x2205e
cmpq %rcx, %rdx
ja 0x2207d
subq %r8, %rcx
jb 0x2209c
testq %r9, %r9
je 0x220bb
movl %esi, %eax
movq %r9, %rsi
subq %rdx, %rsi
movq %rdx, %r10
subq %r8, %r10
cmpq %rdx, %r8
jae 0x2203d
subq %r9, %rcx
jb 0x2203d
leaq (%r8,%r9), %r11
cmpq %rdx, %r11
jb 0x22022
addq %rsi, %r8
cmpq %r... | /pantor[P]inja/third_party/include/nlohmann/json.hpp |
inja::Lexer::scan_number() | Token scan_number() {
for (;;) {
if (pos >= m_in.size()) {
break;
}
const char ch = m_in[pos];
// be very permissive in lexer (we'll catch errors when conversion happens)
if (!(std::isdigit(ch) || ch == '.' || ch == 'e' || ch == 'E' || (ch == '+' && (pos == 0 || m_in[pos-1] == ... | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
movq 0x28(%rsi), %rdx
cmpq %rax, %rdx
jae 0x24d5a
movb (%rcx,%rdx), %dil
movsbl %dil, %r8d
addl $-0x30, %r8d
cmpl $0xa, %r8d
jae 0x24d2a
incq %rdx
movq %rdx, 0x28(%rsi)
jmp 0x24d0a
cmpb $0x65, %dil
je 0x24d21
movzbl %dil, %edi
cmpl $0x2d, %edi
je 0x... | /pantor[P]inja/include/inja/lexer.hpp |
DRAG<RemSP>::FirstScan() | void FirstScan()
{
const int h = img_.rows;
const int w = img_.cols;
LabelsSolver::Setup(); // Labels solver initialization
// We work with 2x2 blocks
// +-+-+-+
// |P|Q|R|
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x60(%rax), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, -0xc(%rbp)
movq 0x60(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0x10(%rbp)
callq 0x350b0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %... | /prittt[P]YACCLAB/include/labeling_bolelli_2018.h |
RemSP::MemMerge(unsigned int, unsigned int) | static unsigned MemMerge(unsigned i, unsigned j)
{
unsigned root_i(i), root_j(j);
while (mem_P_[root_i] != mem_P_[root_j]) {
if (mem_P_[root_i] > mem_P_[root_j]) {
if (root_i == mem_P_[root_i]) {
mem_P_[root_i] = mem_P_[root_j];
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %esi
leaq 0x30b5a4(%rip), %rdi # 0x3427f8
callq 0x2a160
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %esi
l... | /prittt[P]YACCLAB/include/labels_solver.h |
DRAG<TTA>::PerformLabeling() | void PerformLabeling()
{
const int h = img_.rows;
const int w = img_.cols;
img_labels_ = cv::Mat1i(img_.size()); // Memory allocation for the output image
LabelsSolver::Alloc(UPPER_BOUND_8_CONNECTIVITY); // Memory allocation of the labels solver
LabelsSolver::Setup(); // La... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
movq 0x60(%rax), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, -0xc(%rbp)
movq 0x60(%rax), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, -0x10(%rbp)
movq 0x60(%rax), %rsi
addq $0x40, %rsi
leaq -0x78(%... | /prittt[P]YACCLAB/include/labeling_bolelli_2018.h |
DRAG<TTA>::PerformLabelingMem(std::vector<unsigned long, std::allocator<unsigned long>>&) | void PerformLabelingMem(std::vector<uint64_t>& accesses)
{
MemMat<unsigned char> img(img_);
MemMat<int> img_labels(img_.size(), 0);
LabelsSolver::MemAlloc(UPPER_BOUND_8_CONNECTIVITY);
LabelsSolver::MemSetup();
// First scan
int w(img_.cols);
int h(img_.row... | pushq %rbp
movq %rsp, %rbp
subq $0x4a0, %rsp # imm = 0x4A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2d0(%rbp)
movq 0x60(%rax), %rsi
leaq -0x138(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
callq 0x280d0
movq -0x2c8(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x28100
jmp 0x39c4a
le... | /prittt[P]YACCLAB/include/labeling_bolelli_2018.h |
TTA::Merge(unsigned int, unsigned int) | static unsigned Merge(unsigned u, unsigned v)
{
// FindRoot(u);
u = rtable_[u];
// FindRoot(v);
v = rtable_[v];
if (u < v) {
unsigned i = v;
while (i != UINT_MAX) {
rtable_[i] = u;
i = next_[i];
}
... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x307957(%rip), %rax # 0x342828
movq (%rax), %rax
movl -0x8(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
leaq 0x307944(%rip), %rax # 0x342828
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%... | /prittt[P]YACCLAB/include/labels_solver.h |
TTA::Flatten() | static unsigned Flatten()
{
unsigned cur_label = 1;
for (unsigned k = 1; k < length_; k++) {
if (rtable_[k] == k) {
cur_label++;
rtable_[k] = cur_label;
}
else
rtable_[k] = rtable_[rtable_[k]];
}
ret... | pushq %rbp
movq %rsp, %rbp
movl $0x1, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x307794(%rip), %rcx # 0x342840
cmpl (%rcx), %eax
jae 0x3b11d
leaq 0x307771(%rip), %rax # 0x342828
movq (%rax), %rax
movl -0x8(%rbp), %ecx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jne 0x3b0e3
movl -0x4(%rbp), %... | /prittt[P]YACCLAB/include/labels_solver.h |
TTA::Dealloc() | static void Dealloc() {
delete[] rtable_;
delete[] next_;
delete[] tail_;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x3076c9(%rip), %rax # 0x342828
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x3b175
movq -0x8(%rbp), %rdi
callq 0xe220
leaq 0x3076b4(%rip), %rax # 0x342830
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x3b192
movq -0x10(%rbp), %rdi
cal... | /prittt[P]YACCLAB/include/labels_solver.h |
TTA::Alloc(unsigned int, PerformanceEvaluator&) | static double Alloc(unsigned max_length, PerformanceEvaluator& perf) {
perf.start();
rtable_ = new unsigned[max_length];
next_ = new unsigned[max_length];
tail_ = new unsigned[max_length];
memset(rtable_, 0, max_length * sizeof(unsigned));
memset(next_, 0, max_length * si... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25510
movl -0x4(%rbp), %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xe850
movq %rax, %rcx
leaq 0x305922(%rip), %rax # 0x342828
... | /prittt[P]YACCLAB/include/labels_solver.h |
SystemInfo::SetOsBit() | void SystemInfo::SetOsBit()
{
os_bit_ = "";
#if defined(YACCLAB_WINDOWS)
// Compiler independent, works on Windows
typedef BOOL(WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
LPFN_ISWOW64PROCESS fnIsWow64Process;
BOOL bIsWow64 = FALSE;
//IsWow64Process is not available on all supported versions... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
addq $0x60, %rdi
leaq 0x1af7d4(%rip), %rsi # 0x30f0c9
callq 0xe260
leaq -0x18e(%rbp), %rdi
callq 0xe0a0
leaq -0x8a(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x1b1(%rbp), %rdi
movq... | /prittt[P]YACCLAB/src/system_info.cc |
OutputBox::operator=(OutputBox&&) | OutputBox(const std::string& title = "",
const unsigned bar_width = CONSOLE_WIDTH,
const unsigned pre_spaces = 2)
{
pre_spaces_ = pre_spaces;
bar_width_ = bar_width > CONSOLE_WIDTH ? CONSOLE_WIDTH : bar_width;
bar_width_ -= pre_spaces_;
if (title.size() > bar_width... | 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
movl (%rax), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xe8d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x28(%ra... | /prittt[P]YACCLAB/include/progress_bar.h |
std::experimental::net::v1::detail::op_queue<std::experimental::net::v1::detail::reactor_op>::pop() | void pop()
{
if (front_)
{
Operation* tmp = front_;
front_ = op_queue_access::next(front_);
if (front_ == 0)
back_ = 0;
op_queue_access::next(tmp, static_cast<Operation*>(0));
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rax)
je 0x12766
movq (%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
callq 0x12a40
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x12758
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
le... | /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/op_queue.hpp |
bool std::experimental::net::v1::detail::posix_event::maybe_unlock_and_signal_one<std::experimental::net::v1::detail::conditionally_enabled_mutex::scoped_lock>(std::experimental::net::v1::detail::conditionally_enabled_mutex::scoped_lock&) | bool maybe_unlock_and_signal_one(Lock& lock)
{
NET_TS_ASSERT(lock.locked());
state_ |= 1;
if (state_ > 1)
{
lock.unlock();
::pthread_cond_signal(&cond_); // Ignore EINVAL.
return true;
}
return false;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rax), %rcx
orq $0x1, %rcx
movq %rcx, 0x30(%rax)
cmpq $0x1, 0x30(%rax)
jbe 0x12db6
movq 0x10(%rsp), %rdi
callq 0x127e0
movq 0x8(%rsp), %rdi
callq 0x8030
movb $0x1, 0x27(%rsp)
jmp 0x12dbb
movb $0x0, 0x27(%rs... | /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/posix_event.hpp |
std::experimental::net::v1::detail::object_pool<std::experimental::net::v1::detail::epoll_reactor::descriptor_state>::free(std::experimental::net::v1::detail::epoll_reactor::descriptor_state*) | void free(Object* o)
{
if (live_list_ == o)
live_list_ = object_pool_access::next(o);
if (object_pool_access::prev(o))
{
object_pool_access::next(object_pool_access::prev(o))
= object_pool_access::next(o);
}
if (object_pool_access::next(o))
{
object_pool_access::pre... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rax), %rax
cmpq 0x28(%rsp), %rax
jne 0x1328a
movq 0x28(%rsp), %rdi
callq 0x13350
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rdi
callq 0x13360
cmpq $0x0, (%rax)... | /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/object_pool.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> std::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::basic_string_view<char, std::char_traits<char>>, std::__cxx11::... | string format(std::string_view fmt, auto&&... ts) {
if (sizeof...(ts) == 0) return std::string(fmt);
std::array<std::string_view, 32> fragments{};
if (sizeof...(ts) > fragments.size()) throw std::length_error("format parameters count limit exceeded");
size_t index = 0;
auto start = fmt.cbegin(), par... | subq $0x4b8, %rsp # imm = 0x4B8
movq %rdi, 0x50(%rsp)
movq %rdi, %rax
movq %rax, 0x58(%rsp)
movq %rdi, 0x4b0(%rsp)
movq %rsi, 0x4a0(%rsp)
movq %rdx, 0x4a8(%rsp)
movq %rcx, 0x498(%rsp)
movq %r8, 0x490(%rsp)
leaq 0x290(%rsp), %rdi
xorl %esi, %esi
movl $0x200, %edx # imm = 0x200
callq 0x8290
leaq 0x2... | /ambroise-leclerc[P]WebFront/include/http/../details/C++20Support.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> std::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::basic_string_view<char, std::char_traits<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | string format(std::string_view fmt, auto&&... ts) {
if (sizeof...(ts) == 0) return std::string(fmt);
std::array<std::string_view, 32> fragments{};
if (sizeof...(ts) > fragments.size()) throw std::length_error("format parameters count limit exceeded");
size_t index = 0;
auto start = fmt.cbegin(), par... | subq $0x488, %rsp # imm = 0x488
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0x480(%rsp)
movq %rsi, 0x470(%rsp)
movq %rdx, 0x478(%rsp)
movq %rcx, 0x468(%rsp)
leaq 0x268(%rsp), %rdi
xorl %esi, %esi
movl $0x200, %edx # imm = 0x200
callq 0x8290
leaq 0x268(%rsp), %rax
movq %r... | /ambroise-leclerc[P]WebFront/include/http/../details/C++20Support.hpp |
std::experimental::net::v1::detail::posix_thread::posix_thread<std::experimental::net::v1::detail::resolver_service_base::work_io_context_runner>(std::experimental::net::v1::detail::resolver_service_base::work_io_context_runner, unsigned int) | posix_thread(Function f, unsigned int = 0)
: joined_(false)
{
start_thread(new func<Function>(f));
} | subq $0x48, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x129a0
movq 0x8(%rsp), %rax
movb $0x0, 0x8(%rax)
movl $0x10, %edi
callq 0x8450
movq %rax, 0x10(%rsp)
jmp 0x1a36b
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x1... | /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/posix_thread.hpp |
std::experimental::net::v1::ip::basic_resolver<std::experimental::net::v1::ip::tcp>::resolve(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::experimental::net::v1::ip::resolver_base::flags) | results_type resolve(NET_TS_STRING_VIEW_PARAM host,
NET_TS_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags)
{
std::error_code ec;
basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
static_cast<std::string>(service), resolve_flags);
results_type r = this->get_... | subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movl 0x150(%rsp), %eax
movq %rdi, 0x140(%rsp)
movq %rdx, 0x130(%rsp)
movq %rcx, 0x138(%rsp)
movq %r8, 0x120(%rsp)
movq %r9, 0x128(%rsp)
movq %rsi, 0x118(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x108(%r... | /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/ip/basic_resolver.hpp |
bool networking_ts_handler_cont_helpers::is_continuation<webfront::http::Server<webfront::networking::TCPNetworkingTS, webfront::fs::Multi<webfront::fs::NativeDebugFS, webfront::fs::IndexFS, webfront::fs::JasmineFS>>::accept()::'lambda'(std::error_code, std::experimental::net::v1::basic_stream_socket<std::experimental:... | inline bool is_continuation(Context& context)
{
#if !defined(NET_TS_HAS_HANDLER_HOOKS)
return false;
#else
using std::experimental::net::v1::networking_ts_handler_is_continuation;
return networking_ts_handler_is_continuation(
std::experimental::net::v1::detail::addressof(context));
#endif
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movb $0x0, %al
callq 0x1fbb0
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
nop
| /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/handler_cont_helpers.hpp |
void* std::experimental::net::v1::detail::thread_info_base::allocate<std::experimental::net::v1::detail::thread_info_base::default_tag>(std::experimental::net::v1::detail::thread_info_base::default_tag, std::experimental::net::v1::detail::thread_info_base*, unsigned long) | static void* allocate(Purpose, thread_info_base* this_thread,
std::size_t size)
{
std::size_t chunks = (size + chunk_size - 1) / chunk_size;
if (this_thread && this_thread->reusable_memory_[Purpose::mem_index])
{
void* const pointer = this_thread->reusable_memory_[Purpose::mem_index];
t... | subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x1fe13
movq 0x40(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1fe13
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax... | /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/thread_info_base.hpp |
void networking_ts_handler_invoke_helpers::invoke<std::experimental::net::v1::detail::move_binder2<webfront::http::Server<webfront::networking::TCPNetworkingTS, webfront::fs::Multi<webfront::fs::NativeDebugFS, webfront::fs::IndexFS, webfront::fs::JasmineFS>>::accept()::'lambda'(std::error_code, std::experimental::net::... | inline void invoke(Function& function, Context& context)
{
#if !defined(NET_TS_HAS_HANDLER_HOOKS)
Function tmp(function);
tmp();
#else
using std::experimental::net::v1::networking_ts_handler_invoke;
networking_ts_handler_invoke(function, std::experimental::net::v1::detail::addressof(context));
#endif
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movb $0x0, %al
callq 0x20a60
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/handler_invoke_helpers.hpp |
webfront::http::Connection<webfront::networking::TCPNetworkingTS, webfront::fs::Multi<webfront::fs::NativeDebugFS, webfront::fs::IndexFS, webfront::fs::JasmineFS>>::Connection(std::experimental::net::v1::basic_stream_socket<std::experimental::net::v1::ip::tcp>, webfront::http::Connections<webfront::http::Connection<web... | explicit Connection(typename Net::Socket sock, Connections<Connection>& connectionsHandler,
RequestHandler<Net, FS>& handler)
: socket(std::move(sock)), connections(connectionsHandler), requestHandler(handler) {
log::debug("New connection");
} | subq $0x78, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x21890
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
callq 0x218a0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x30, %rdi... | /ambroise-leclerc[P]WebFront/include/http/HTTPServer.hpp |
webfront::http::Connection<webfront::networking::TCPNetworkingTS, webfront::fs::Multi<webfront::fs::NativeDebugFS, webfront::fs::IndexFS, webfront::fs::JasmineFS>>::read() | void read() {
auto self(this->shared_from_this());
socket.async_read_some(Net::Buffer(buffer), [this, self](std::error_code ec, std::size_t bytesTransferred) {
if (!ec) {
switch (protocol) {
case Protocol::HTTP:
try {
... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rsi
movq %rsi, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x237e0
movq 0x8(%rsp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, 0x10(%rsp)
addq $0x60, %rdi
callq 0x23890
movq (%rsp), %rsi
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rsp)
... | /ambroise-leclerc[P]WebFront/include/http/HTTPServer.hpp |
void std::experimental::net::v1::detail::reactive_socket_service_base::async_receive<std::experimental::net::v1::mutable_buffer, webfront::http::Connection<webfront::networking::TCPNetworkingTS, webfront::fs::Multi<webfront::fs::NativeDebugFS, webfront::fs::IndexFS, webfront::fs::JasmineFS>>::read()::'lambda'(std::erro... | void async_receive(base_implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
{
bool is_continuation =
networking_ts_handler_cont_helpers::is_continuation(handler);
// Allocate and construct an operation to wrap the handler.
... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
movq %r8, 0x70(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
callq 0x23cb0
movb %al, 0x6f(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
callq 0x23cd0
movq %rax, 0x... | /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/reactive_socket_service_base.hpp |
webfront::http::Request::completeRequest(char) | bool completeRequest(char input) {
auto isChar = [](char c) { return c >= 0; };
auto isCtrl = [](char c) { return (c >= 0 && c <= 31) || (c == 127); };
auto isSpecial = [](char c) { switch (c) {
case '(': case ')': case '<': case '>': case '@': case ',': case ';': case ':': case '\... | subq $0xf8, %rsp
movb %sil, %al
movq %rdi, 0xe8(%rsp)
movb %al, 0xe7(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x68(%rsp)
movb 0x2330d(%rip), %cl # 0x49049
movb %cl, 0xe6(%rsp)
movb 0x23301(%rip), %cl # 0x4904a
movb %cl, 0xe5(%rsp)
movb 0x232f5(%rip), %cl # 0x4904b
movb %cl, 0xe4(%rsp)
movb 0x232e9(%rip), %... | /ambroise-leclerc[P]WebFront/include/http/HTTPServer.hpp |
webfront::fs::File::File(std::span<unsigned long const, 18446744073709551615ul>, unsigned long, std::basic_string_view<char, std::char_traits<char>>) | File(std::span<const uint64_t> input, size_t fileSize, std::string_view contentEncoding = "")
: fileType{FileType::staticData}, data(input), size(fileSize), eofBit(fileSize==0), encoding(contentEncoding) {} | subq $0x68, %rsp
movq %rsi, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, (%rax)
movups 0x58(%rsp), %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x20(%ra... | /ambroise-leclerc[P]WebFront/include/http/../system/FileSystem.hpp |
webfront::http::Headers::getHeadersValues[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>) const | [[nodiscard]] std::list<std::string> getHeadersValues(std::string_view headerName) const {
std::list<std::string> values{};
for (auto& header : headers)
if (caseInsensitiveEqual(header.name, headerName)) values.push_back(header.value);
return values;
} | subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x90(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x88(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x77(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x8290
movq 0x10(%rsp), %rdi
callq 0x2e230
movq 0x1... | /ambroise-leclerc[P]WebFront/include/http/HTTPServer.hpp |
std::vector<webfront::networking::TCPNetworkingTS::ConstBuffer, std::allocator<webfront::networking::TCPNetworkingTS::ConstBuffer>> webfront::http::Response::toBuffers<webfront::networking::TCPNetworkingTS>() const | [[nodiscard]] std::vector<typename Net::ConstBuffer> toBuffers() const {
std::vector<typename Net::ConstBuffer> buffers;
static std::string httpStatus;
httpStatus = "HTTP/1.1 " + std::to_string(statusCode) + " " + toString(statusCode) + "\r\n";
buffers.push_back(Net::Buffer(httpStatus));... | subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1b0(%rsp)
movq %rsi, 0x1a8(%rsp)
movq 0x1a8(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x1a7(%rsp)
callq 0x34b40
cmpb $0x0, 0x45b93(%rip) # 0x77618
jne 0x31aca
leaq 0x45b8a(%rip), %rdi # 0x77618... | /ambroise-leclerc[P]WebFront/include/http/HTTPServer.hpp |
void std::experimental::net::v1::detail::reactive_socket_service_base::async_send<std::experimental::net::v1::detail::prepared_buffers<std::experimental::net::v1::const_buffer, 64ul>, std::experimental::net::v1::detail::write_op<std::experimental::net::v1::basic_stream_socket<std::experimental::net::v1::ip::tcp>, std::... | void async_send(base_implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
{
bool is_continuation =
networking_ts_handler_cont_helpers::is_continuation(handler);
// Allocate and construct an operation to wrap the handler.
type... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
movq %r8, 0x70(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
callq 0x33500
movb %al, 0x6f(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
callq 0x33520
movq %rax, 0x... | /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/reactive_socket_service_base.hpp |
void networking_ts_handler_alloc_helpers::deallocate<std::experimental::net::v1::detail::write_op<std::experimental::net::v1::basic_stream_socket<std::experimental::net::v1::ip::tcp>, std::vector<std::experimental::net::v1::const_buffer, std::allocator<std::experimental::net::v1::const_buffer>>, __gnu_cxx::__normal_ite... | inline void deallocate(void* p, std::size_t s, Handler& h)
{
#if !defined(NET_TS_HAS_HANDLER_HOOKS)
::operator delete(p);
#else
using std::experimental::net::v1::networking_ts_handler_deallocate;
networking_ts_handler_deallocate(p, s, std::experimental::net::v1::detail::addressof(h));
#endif
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x33d50
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/handler_alloc_helpers.hpp |
void networking_ts_handler_invoke_helpers::invoke<std::experimental::net::v1::detail::binder2<std::experimental::net::v1::detail::write_op<std::experimental::net::v1::basic_stream_socket<std::experimental::net::v1::ip::tcp>, std::vector<std::experimental::net::v1::const_buffer, std::allocator<std::experimental::net::v1... | inline void invoke(Function& function, Context& context)
{
#if !defined(NET_TS_HAS_HANDLER_HOOKS)
Function tmp(function);
tmp();
#else
using std::experimental::net::v1::networking_ts_handler_invoke;
networking_ts_handler_invoke(function, std::experimental::net::v1::detail::addressof(context));
#endif
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x33de0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/handler_invoke_helpers.hpp |
std::experimental::net::v1::detail::reactive_socket_send_op_base<std::experimental::net::v1::detail::prepared_buffers<std::experimental::net::v1::const_buffer, 64ul>>::do_perform(std::experimental::net::v1::detail::reactor_op*) | static status do_perform(reactor_op* base)
{
reactive_socket_send_op_base* o(
static_cast<reactive_socket_send_op_base*>(base));
buffer_sequence_adapter<std::experimental::net::v1::const_buffer,
ConstBufferSequence> bufs(o->buffers_);
status result = socket_ops::non_blocking_send(o->sock... | subq $0x448, %rsp # imm = 0x448
movq %rdi, 0x440(%rsp)
movq 0x440(%rsp), %rax
movq %rax, 0x438(%rsp)
movq 0x438(%rsp), %rsi
addq $0x40, %rsi
leaq 0x28(%rsp), %rdi
callq 0x33fd0
movq 0x438(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x34190
movq %rax, 0x18(%rsp)
leaq 0x... | /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/reactive_socket_send_op.hpp |
std::experimental::net::v1::operator+(std::experimental::net::v1::const_buffer const&, unsigned long) | inline const_buffer operator+(const const_buffer& b,
std::size_t n) NET_TS_NOEXCEPT
{
std::size_t offset = n < b.size() ? n : b.size();
const char* new_data = static_cast<const char*>(b.data()) + offset;
std::size_t new_size = b.size() - offset;
return const_buffer(new_data, new_size
#if defined(NET_TS_ENAB... | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x32cf0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x3472a
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
jmp 0x34738
movq 0x30(%rsp), %rdi
callq 0x32cf0
movq %rax, (%rsp)
movq (%rs... | /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/buffer.hpp |
webfront::websocket::WebSocket<webfront::networking::TCPNetworkingTS>::writeData(webfront::websocket::Frame<webfront::networking::TCPNetworkingTS>) | void writeData(Frame<Net> frame) {
Net::AsyncWrite(socket, frame.toBuffers(), [this](std::error_code ec, std::size_t /*bytesTransferred*/) {
if (ec) {
if (started) {
log::error("Error during write : ec.value() = {}", ec.value());
if (closeHandl... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3c450
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rdi, 0x28(%rsp)
leaq 0x28(%rsp), %rdx
callq 0x3c420
jmp 0x3c292
leaq 0x30(%rsp), %rdi
callq 0x31ee0
addq $0x5... | /ambroise-leclerc[P]WebFront/include/http/WebSocket.hpp |
std::experimental::net::v1::async_result<std::decay<webfront::websocket::WebSocket<webfront::networking::TCPNetworkingTS>::writeData(webfront::websocket::Frame<webfront::networking::TCPNetworkingTS>)::'lambda'(std::error_code, unsigned long)>::type, void (std::error_code, unsigned long)>::return_type std::experimental:... | async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
NET_TS_MOVE_ARG(WriteHandler) handler,
typename enable_if<
is_const_buffer_sequence<ConstBufferSequence>::value
>::type*)
{
// If you get an error on the following line it means that your handler does
// not meet the documented t... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3c500
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x320a0
movq %rax, 0x20(%rsp)
callq 0x320d... | /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/impl/write.hpp |
void networking_ts_handler_invoke_helpers::invoke<std::experimental::net::v1::detail::binder2<std::experimental::net::v1::detail::write_op<std::experimental::net::v1::basic_stream_socket<std::experimental::net::v1::ip::tcp>, std::vector<std::experimental::net::v1::const_buffer, std::allocator<std::experimental::net::v1... | inline void invoke(Function& function, Context& context)
{
#if !defined(NET_TS_HAS_HANDLER_HOOKS)
Function tmp(function);
tmp();
#else
using std::experimental::net::v1::networking_ts_handler_invoke;
networking_ts_handler_invoke(function, std::experimental::net::v1::detail::addressof(context));
#endif
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movb $0x0, %al
callq 0x3d430
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/handler_invoke_helpers.hpp |
void* networking_ts_handler_alloc_helpers::allocate<webfront::websocket::WebSocket<webfront::networking::TCPNetworkingTS>::read()::'lambda'(std::error_code, unsigned long)>(unsigned long, webfront::websocket::WebSocket<webfront::networking::TCPNetworkingTS>::read()::'lambda'(std::error_code, unsigned long)&) | inline void* allocate(std::size_t s, Handler& h)
{
#if !defined(NET_TS_HAS_HANDLER_HOOKS)
return ::operator new(s);
#else
using std::experimental::net::v1::networking_ts_handler_allocate;
return networking_ts_handler_allocate(s, std::experimental::net::v1::detail::addressof(h));
#endif
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movb $0x0, %al
callq 0x1fcf0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/handler_alloc_helpers.hpp |
void networking_ts_handler_alloc_helpers::deallocate<webfront::websocket::WebSocket<webfront::networking::TCPNetworkingTS>::read()::'lambda'(std::error_code, unsigned long)>(void*, unsigned long, webfront::websocket::WebSocket<webfront::networking::TCPNetworkingTS>::read()::'lambda'(std::error_code, unsigned long)&) | inline void deallocate(void* p, std::size_t s, Handler& h)
{
#if !defined(NET_TS_HAS_HANDLER_HOOKS)
::operator delete(p);
#else
using std::experimental::net::v1::networking_ts_handler_deallocate;
networking_ts_handler_deallocate(p, s, std::experimental::net::v1::detail::addressof(h));
#endif
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movb $0x0, %al
callq 0x20960
addq $0x18, %rsp
retq
nopl (%rax)
| /ambroise-leclerc[P]WebFront/build_O0/_deps/networking-ts-impl-src/include/experimental/__net_ts/detail/handler_alloc_helpers.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> std::format<bool, bool, bool, bool, int>(std::basic_string_view<char, std::char_traits<char>>, bool&&, bool&&, bool&&, bool&&, int&&) | string format(std::string_view fmt, auto&&... ts) {
if (sizeof...(ts) == 0) return std::string(fmt);
std::array<std::string_view, 32> fragments{};
if (sizeof...(ts) > fragments.size()) throw std::length_error("format parameters count limit exceeded");
size_t index = 0;
auto start = fmt.cbegin(), par... | subq $0x4f8, %rsp # imm = 0x4F8
movq %rdi, 0x60(%rsp)
movq %rdi, %rax
movq %rax, 0x68(%rsp)
movq 0x508(%rsp), %rax
movq 0x500(%rsp), %rax
movq %rdi, 0x4f0(%rsp)
movq %rsi, 0x4e0(%rsp)
movq %rdx, 0x4e8(%rsp)
movq %rcx, 0x4d8(%rsp)
movq %r8, 0x4d0(%rsp)
movq %r9, 0x4c8(%rsp)
leaq 0x2c8(%rsp), %rdi
xorl %esi, %... | /ambroise-leclerc[P]WebFront/include/http/../details/C++20Support.hpp |
void webfront::msg::FunctionCall::encodeParameter<char const (&) [12], webfront::websocket::Frame<webfront::networking::TCPNetworkingTS>>(char const (&) [12], webfront::websocket::Frame<webfront::networking::TCPNetworkingTS>&) | void encodeParameter(T&& t, WebSocketFrame& frame) {
using namespace std;
using ParamType = remove_cvref_t<T>;
setParametersCount(getParametersCount() + 1);
if constexpr (is_printable<T>::value) {
std::cout << "Param: " << typeName<T>() << " -> " << typeName<ParamType>() << ... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x415c0
movq 0x10(%rsp), %rdi
movzbl %al, %eax
addl $0x1, %eax
movzbl %al, %esi
callq 0x415a0
movq 0x2fa24(%rip), %rdi # 0x76fb0
leaq 0x399e(%rip), %rsi # 0x4af31
callq 0x8440
mo... | /ambroise-leclerc[P]WebFront/include/weblink/Messages.hpp |
auto webfront::msg::FunctionCall::typeName<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>() | constexpr auto typeName() {
#if defined(_MSC_VER)
std::string_view tName = __FUNCSIG__, prefix = "auto __cdecl JSFunction::typeName<", suffix = ">(void)";
#elif __clang__
std::string_view tName = __PRETTY_FUNCTION__, prefix = "auto webfront::JSFunction::typeName() [T = ", suffix = "]";
#elif defined(__G... | subq $0x68, %rsp
movq %rdi, 0x48(%rsp)
leaq 0x35be(%rip), %rsi # 0x4af3e
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xc5b0
leaq 0x35f5(%rip), %rsi # 0x4af8b
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xc5b0
leaq 0x35de(%rip), %rsi # 0x4af89
leaq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xc5b... | /ambroise-leclerc[P]WebFront/include/weblink/Messages.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> std::format<std::basic_string_view<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_t... | string format(std::string_view fmt, auto&&... ts) {
if (sizeof...(ts) == 0) return std::string(fmt);
std::array<std::string_view, 32> fragments{};
if (sizeof...(ts) > fragments.size()) throw std::length_error("format parameters count limit exceeded");
size_t index = 0;
auto start = fmt.cbegin(), par... | subq $0x4c8, %rsp # imm = 0x4C8
movq %rdi, 0x50(%rsp)
movq %rdi, %rax
movq %rax, 0x58(%rsp)
movq %rdi, 0x4c0(%rsp)
movq %rsi, 0x4b0(%rsp)
movq %rdx, 0x4b8(%rsp)
movq %rcx, 0x4a8(%rsp)
movq %r8, 0x4a0(%rsp)
leaq 0x2a0(%rsp), %rdi
xorl %esi, %esi
movl $0x200, %edx # imm = 0x200
callq 0x8290
leaq 0x2... | /ambroise-leclerc[P]WebFront/include/http/../details/C++20Support.hpp |
bsp_init | void bsp_init( void (*spmd_part)(void), int argc, char *argv[])
{
int pid = -1;
int mpi_init = 0;
MPI_Initialized(&mpi_init);
if (!mpi_init) {
MPI_Init(&argc, &argv);
atexit( bsp_check_exit );
}
if (s_spmd)
bsp_abort( "bsp_init: May be called only once\n" );
if (!sp... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movq %rdx, 0x8(%rsp)
orl $-0x1, (%rsp)
leaq 0x14(%rsp), %r14
andl $0x0, (%r14)
movq %r14, %rdi
callq 0x8150
cmpl $0x0, (%r14)
jne 0x8847
leaq 0x4(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8400
leaq 0xb9(%rip), %rdi # 0x88fb
callq 0x11570
... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bsp_send | void bsp_send( bsp_pid_t pid, const void * tag, const void * payload,
bsp_size_t payload_nbytes )
{
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_send: can only be called within SPMD section\n");
if (pid < 0 || pid >= s_spmd->nprocs())
bsp_abort("bsp_send: The source process ID does n... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
movq 0x10aa1(%rip), %rax # 0x1a2c8
testq %rax, %rax
je 0x9832
cmpb $0x1, 0x8(%rax)
jne 0x9840
leaq 0x94e9(%rip), %rdi # 0x12d22
xorl %eax, %eax
callq 0x8641
testl %r15d, %r15d
js 0x9852
movq ... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
mcbsp_send | void mcbsp_send( mcbsp_pid_t pid, const void * tag,
const void * payload, mcbsp_size_t size )
{
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_send: can only be called within SPMD section\n");
if (pid > mcbsp_pid_t(s_spmd->nprocs()))
bsp_abort("bsp_send: The source process ID doe... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movq 0x10261(%rip), %rax # 0x1a2c8
testq %rax, %rax
je 0xa072
cmpb $0x1, 0x8(%rax)
jne 0xa087
leaq 0x8ca9(%rip), %rdi # 0x12d22
xorl %eax, %eax
callq 0x8641
movq 0x10241(%rip), %rax # 0x1a... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
mcbsp_get_tag | void mcbsp_get_tag( mcbsp_size_t * status, void * tag )
{
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_get_tag: can only be called within SPMD section\n");
#ifdef PROFILE
TicToc t( TicToc::BSMP, s_bsmp->recv_tag_size() );
#endif
if ( status == NULL )
bsp_abort("bsp_get_tag: first argume... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1015b(%rip), %rax # 0x1a2c8
testq %rax, %rax
je 0xa178
cmpb $0x1, 0x8(%rax)
jne 0xa186
leaq 0x8deb(%rip), %rdi # 0x12f6a
xorl %eax, %eax
callq 0x8641
testq %r14, %r14
jne 0xa199
leaq 0x8e0d(%rip), %rdi # 0x12f9f
xorl %eax, %eax
callq ... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bool bsplib::read_env<int>(char const*, int&) | bool read_env( const char * str, T & result ) {
#if HAS_DUPENV_S_WIN32
char * env = NULL;
if (_dupenv_s( &env, NULL , str) )
return false;
#else
const char * env = std::getenv( str );
#endif
if (env) {
std::istringstream s( env );
#if HAS_DUPENV_S_WIN32
... | pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %rbx
callq 0x8330
testq %rax, %rax
je 0xa3bb
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xa490
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x8490
leaq 0x10(%rsp), %rdi
callq 0x80e0
leaq 0x30(%rsp), %rdi
mov... | /wijnand-suijlen[P]bsponmpi/src/config.h |
bool bsplib::read_env<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool read_env( const char * str, T & result ) {
#if HAS_DUPENV_S_WIN32
char * env = NULL;
if (_dupenv_s( &env, NULL , str) )
return false;
#else
const char * env = std::getenv( str );
#endif
if (env) {
std::istringstream s( env );
#if HAS_DUPENV_S_WIN32
... | pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %rbx
callq 0x8330
testq %rax, %rax
je 0xa537
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xa490
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x8490
leaq 0x10(%rsp), %rdi
callq 0x80e0
leaq 0x30(%rsp), %rdi
mov... | /wijnand-suijlen[P]bsponmpi/src/config.h |
bsplib::Spmd::time() const | double time() const {
struct timespec now;
clock_gettime( CLOCK_MONOTONIC, &now );
return (now.tv_sec - m_time.tv_sec)
+ 1e-9 * (now.tv_nsec - m_time.tv_nsec );
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x8280
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq 0x10(%rbx), %rax
cvtsi2sd %rax, %xmm1
subq 0x18(%rbx), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0x79e7(%rip), %xmm0 # 0x12048
addsd %xmm1, %xmm0
addq $0x18... | /wijnand-suijlen[P]bsponmpi/src/spmd.h |
bsplib::Unbuf::Unbuf(unsigned long, ompi_communicator_t*) | Unbuf::Unbuf( size_t max_msg_size, MPI_Comm comm)
: m_pid(-1), m_nprocs(-1)
, m_comm(MPI_COMM_NULL)
, m_max_msg_size( max_msg_size )
{
MPI_Comm_dup( comm, &m_comm );
MPI_Comm_size( m_comm, &m_nprocs );
MPI_Comm_rank( m_comm, &m_pid );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
orq $-0x1, (%rdi)
leaq 0x8(%rdi), %r15
movq 0xdc2e(%rip), %rax # 0x19fb8
movq %rax, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
leaq 0x18(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0... | /wijnand-suijlen[P]bsponmpi/src/unbuf.cc |
bsplib::Unbuf::start() | void Unbuf :: start( )
{
m_reqs.resize( m_sends.size() + m_recvs.size() );
size_t j = 0;
for ( size_t i = 0 ; i < m_recvs.size(); ++j, ++i ) {
Entry & u = m_recvs[i];
size_t size = std::min( m_max_msg_size, u.size );
char * addr = const_cast<char *>( u.addr );
char * next_addr = add... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x48, %rdi
movq 0x20(%rbx), %rax
movq 0x38(%rbx), %rsi
subq 0x18(%rbx), %rax
sarq $0x5, %rax
subq 0x30(%rbx), %rsi
sarq $0x5, %rsi
addq %rax, %rsi
callq 0xca7a
xorl %r15d, %r15d
movq 0xd8ea(%rip), %r14 # 0x19f80
xorl %r12... | /wijnand-suijlen[P]bsponmpi/src/unbuf.cc |
bsplib::exception::what() const | virtual const char * what() const throw()
{ m_buf = m_stream.str();
return m_buf.c_str();
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x8430
leaq 0x180(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x8340
movq %r14, %rdi
callq 0x80e0
movq 0x180(%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xa66d
nop
| /wijnand-suijlen[P]bsponmpi/src/exception.h |
bsplib::Rdma::pop_reg(unsigned long) | void Rdma::pop_reg( Memslot id )
{
assert( id == null_slot() || !( slot(m_pid, id ).status & Memblock::POPPED) );
if ( id != null_slot() ) {
slot( m_pid, id ).status |= Memblock::POPPED;
}
m_send_push_pop_comm_buf.m_popped_slots.push_back( id );
} | pushq %rax
movq %rsi, (%rsp)
cmpq $-0x2, %rsi
je 0xd105
movslq 0x2f4(%rdi), %rax
imulq %rsi, %rax
imulq $0x18, %rax, %rax
addq 0x338(%rdi), %rax
movslq 0x2f0(%rdi), %rcx
imulq $0x18, %rcx, %rdx
movl 0x10(%rdx,%rax), %ecx
testb $0x2, %cl
jne 0xd116
addq %rdx, %rax
addq $0x10, %rax
orl $0x2, %ecx
movl %ecx, (%rax)
addq $... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
bsplib::Rdma::put(void const*, int, unsigned long, unsigned long, unsigned long) | void Rdma::put( const void * src,
int dst_pid, Memslot dst_slot, size_t dst_offset, size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::PUT );
size_t t_a = m_second_exchange.send_size(dst_pid);
#endif
assert( ! (slot( m_pid, dst_slot ).status & Memblock::PUSHED) );
serial( m_second_exchange, dst_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movslq 0x2f4(%rdi), %rax
imulq %rcx, %rax
imulq $0x18, %rax, %rax
addq 0x338(%rdi), %rax
movslq 0x2f0(%rdi), %rcx
imulq $0x18, %rcx, %rcx
testb $0x1, 0x10(%rcx,%rax)
jne 0xd1c4
movq %r9, %rbx
movq %r8, %r15
movl %edx, %ebp
movq... | /wijnand-suijlen[P]bsponmpi/src/rdma.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 0xd42b
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::sync(bool) | bool Rdma::sync(bool dummy_bsmp)
{
m_send_actions.set_dummy_bsmp(dummy_bsmp);
m_send_actions.set_get_buffer_offset( m_second_exchange );
// first exchange: gets, unbuffered requests, push/pop registers
m_send_push_pop_comm_buf.serialize( m_first_exchange );
m_send_actions.serialize( m_first_exchang... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x388(%rdi), %r14
movl %esi, 0x3d0(%rdi)
leaq 0x178(%rdi), %rbp
movq %r14, %rdi
movq %rbp, %rsi
callq 0xe876
leaq 0x4a0(%rbx), %rdi
movq %rdi, (%rsp)
movq %rbx, %rsi
callq 0xd7e4
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd93... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
bsplib::Rdma::PushPopCommBuf::serialize(bsplib::A2A&) | void Rdma::PushPopCommBuf::serialize( A2A & a2a )
{
typedef UIntSerialize< size_t > SizeSer;
const size_t n_pushed_slots = m_pushed_slots.size();
const size_t n_popped_slots = m_popped_slots.size();
// broadcast pushed slots
{ SizeSer::Buffer nbuf;
const int n_nbuf = SizeSer::write( n_pu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, (%rsp)
movq %rdi, %r14
movq 0x8(%rdi), %rdi
subq (%r14), %rdi
movq 0x20(%r14), %rax
sarq $0x5, %rdi
subq 0x18(%r14), %rax
movq %rax, 0x20(%rsp)
leaq 0x16(%rsp), %rsi
callq 0xab4a
cltq
movq %rax, 0x28(%rsp)
xorl %esi, %esi
movq... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
bsplib::Rdma::ActionBuf::deserialize(bsplib::A2A&) | void Rdma::ActionBuf::deserialize( A2A & a2a )
{
size_t n = 0;
m_dummy_bsmp = true;
for (int p = 0; p < a2a.nprocs(); ++p )
{
unsigned dummy;
deserial( a2a, p, dummy );
deserial( a2a, p, m_get_buffer_offset[ p ] );
deserial( a2a, p, m_counts[ p ] );
n += m_counts... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, 0x48(%rdi)
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jge 0xdebf
movq %r14, %rdi
movl %r13d, %esi
movq %r12, %rdx
callq 0xe96... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
bsplib::UIntSerialize<unsigned int>::write(unsigned int, unsigned char (&) [5]) | static int write( UInt x, Buffer & bytes ) {
assert( x >= 0 );
int i = 0;
do {
unsigned char m = (1 << (CHAR_BIT-1));
unsigned char c = x & (m-1); // cut out least significant bits
x >>= (CHAR_BIT-1); // and save these in c
c |= (x > 0) * ... | xorl %eax, %eax
movl %edi, %ecx
movl %edi, %edx
andl $0x7f, %edx
shrl $0x7, %ecx
xorl %r8d, %r8d
cmpl $0x7f, %edi
seta %r8b
shll $0x7, %r8d
orl %edx, %r8d
movb %r8b, (%rsi,%rax)
incq %rax
cmpl $0x7f, %edi
movl %ecx, %edi
ja 0xf696
retq
| /wijnand-suijlen[P]bsponmpi/src/uintserialize.h |
bsplib::UIntSerialize<unsigned int>::read(unsigned char const*, unsigned int&) | static int read( const unsigned char * cs, UInt & x ) {
x = 0;
int i = 0;
unsigned char m = (1 << (CHAR_BIT-1));
unsigned char c = 0;
UInt power = 1;
do {
c = cs[i++];
x += power * (c & (m-1));
power <<= (CHAR_BIT-1);
} while (c... | andl $0x0, (%rsi)
pushq $0x1
popq %rcx
xorl %eax, %eax
xorl %edx, %edx
movzbl (%rdi,%rax), %r8d
incq %rax
movl %r8d, %r9d
andl $0x7f, %r9d
imull %ecx, %r9d
addl %r9d, %edx
movl %edx, (%rsi)
shll $0x7, %ecx
testb %r8b, %r8b
js 0xf716
retq
nop
| /wijnand-suijlen[P]bsponmpi/src/uintserialize.h |
bsplib::AlignedBuf::append(unsigned long) | void * append( size_t extra_bytes ) {
extra_bytes = align( extra_bytes );
if ( m_size + extra_bytes > m_capacity ) {
size_t newsize = std::max( 2 * m_capacity, m_size + extra_bytes );
void * ptr = std::malloc( newsize + 2*m_alignment );
void * aligned_ptr = align( ptr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r13
movq 0x18(%rdi), %rbp
leaq (%rsi,%r13), %r14
decq %r14
movq %r14, %rax
xorl %edx, %edx
divq %r13
subq %rdx, %r14
movq 0x20(%rdi), %r12
leaq (%r12,%r14), %rax
cmpq %rbp, %rax
jbe 0x10200
leaq -0x1(%r13), %r15
a... | /wijnand-suijlen[P]bsponmpi/src/aligned_buf.h |
license::test::read_disk_id::test_method() | BOOST_AUTO_TEST_CASE(read_disk_id) {
os::ExecutionEnvironment exec_env;
LCC_API_VIRTUALIZATION_SUMMARY virt = exec_env.virtualization();
vector<DiskInfo> disk_infos;
FUNCTION_RETURN result = getDiskInfos(disk_infos);
if (virt == LCC_API_VIRTUALIZATION_SUMMARY::NONE || virt == LCC_API_VIRTUALIZATION_SUMMARY::VM) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp # imm = 0x808
leaq 0x218(%rsp), %rbx
movq %rbx, %rdi
callq 0x1e74c
movq %rbx, %rdi
callq 0x1dc38
movl %eax, %ebx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x1fe77
movl %eax, 0x4... | /open-license-manager[P]licensecc/test/library/os_linux_test.cpp |
getOsSpecificIdentifier(unsigned char*) | FUNCTION_RETURN getOsSpecificIdentifier(unsigned char identifier[6]) {
#if USE_DBUS
char *dbus_id = dbus_get_local_machine_id();
if (dbus_id == NULL) {
return FUNC_RET_ERROR;
}
memcpy(identifier, dbus_id, 6);
dbus_free(dbus_id);
return FUNC_RET_OK;
#else
return FUNC_RET_NOT_AVAIL;
#endif
} | movl $0x1, %eax
retq
| /open-license-manager[P]licensecc/src/library/os/linux/os_linux.cpp |
license::trim_copy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string trim_copy(const string &string_to_trim) {
std::string::const_iterator it = string_to_trim.begin();
while (it != string_to_trim.end() && isspace(*it)) {
++it;
}
std::string::const_reverse_iterator rit = string_to_trim.rbegin();
while (rit.base() != it && (isspace(*rit) || *rit == 0)) {
++rit;
}
return ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r12
leaq (%r14,%r12), %r15
testq %r12, %r12
je 0x20fcf
movsbl (%r14), %edi
callq 0x110a0
testl %eax, %eax
je 0x20fcf
incq %r14
decq %r12
jne 0x20fb7
movq %r15, %r14
cmpq %r14, %r15
je 0x20ff0
movsbl -0x1(%r15), %eb... | /open-license-manager[P]licensecc/src/library/base/string_utils.cpp |
testing::internal::GetRandomSeedFromFlag(int) | inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
const unsigned int raw_seed = (random_seed_flag == 0) ?
static_cast<unsigned int>(GetTimeInMillis()) :
static_cast<unsigned int>(random_seed_flag);
// Normalizes the actual seed to range [1, kMaxRandomSeed] such that
// it's easy to type.
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x3fb2b
callq 0x13530
movl %eax, -0x10(%rbp)
jmp 0x3fb31
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl $0x1869f, %ecx # imm = 0x1869... | /metacall[P]core/build_O0/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h |
testing::Message& testing::Message::operator<<<char [21]>(char const (&) [21]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xdce0
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0xa680
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /metacall[P]core/build_O0/source/tests/src/google-test-depends/googletest/include/gtest/gtest-message.h |
testing::internal::DeathTestImpl::~DeathTestImpl() | ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq 0x4359f(%rip), %rcx # 0x86110
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x100(%rbp), %rax
cmpl $-0x1, 0x34(%rax)
sete %al
movzbl %al, %edi
andl $0x1, %edi
callq 0xf520
testb ... | /metacall[P]core/build_O0/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
change_setting_proc(Am_Object) | Am_Define_Method(Am_Object_Method, void, change_setting, (Am_Object self))
{
Am_Object inter = self.Get_Owner();
Am_Input_Char c = inter.Get(Am_START_CHAR);
if (c == "q") {
Am_Exit_Main_Event_Loop();
} else if (c == "S") {
static bool switcher = false;
if (switcher) {
switcher = false;
m... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rsi
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0x2330
movq %rbx, %rdi
movl $0x11b, %esi # imm = 0x11B
xorl %edx, %edx
callq 0x2240
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x2a52
movzwl (%rax), %eax
movq 0x455f(%rip), %rdx ... | /ProgrammerArchaeology[P]openamulet/test/opal/testmap.cpp |
map_fill_proc(Am_Object&) | Am_Define_Style_Formula(map_fill)
{
int rank = self.Get(Am_RANK);
switch (rank) {
case 0:
return Am_Red;
case 1:
return Am_Blue;
case 2:
return Am_Green;
case 3:
return Am_Orange;
case 4:
return Am_Purple;
case 5:
return Am_Cyan;
case 6:
return Am_Yellow;
default:
ret... | pushq %rax
movl $0x85, %esi
xorl %edx, %edx
callq 0x2240
movq %rax, %rdi
callq 0x21c0
cmpl $0x6, %eax
ja 0x36f3
movl %eax, %eax
leaq 0x359b(%rip), %rcx # 0x6c88
movq (%rcx,%rax,8), %rdi
jmp 0x36fa
movq 0x38ce(%rip), %rdi # 0x6fc8
popq %rax
jmp 0x21a0
| /ProgrammerArchaeology[P]openamulet/test/opal/testmap.cpp |
Am_Input_Char::operator==(Am_Input_Char) const | bool operator==(Am_Input_Char i) const
{
//quick exit for mouse_moved == something else, for efficiency.
// Mouse-moved doesn't match ANY-* so is an easy test
if ((i.code == Am_MOUSE_MOVED && code != Am_MOUSE_MOVED) ||
(code == Am_MOUSE_MOVED && i.code != Am_MOUSE_MOVED))
return false;
e... | movzwl %si, %eax
movl $0x103, %ecx # imm = 0x103
cmpl %ecx, %eax
setne %al
movzwl (%rdi), %edx
cmpl %ecx, %edx
sete %cl
movl %eax, %edx
orb %cl, %dl
xorb $0x1, %dl
andb %cl, %al
orb %dl, %al
je 0x2080
xorl %eax, %eax
retq
nop
| /ProgrammerArchaeology[P]openamulet/include/amulet/idefs.h |
CombinedSeismogramm<float, 2>::Load(SeismoType, 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>>>>) | void CombinedSeismogramm<Scalar, dims>::Load(SeismoType type, std::vector<std::string> paths)
{
seismogramms.resize(componentInfos.size());
if (type == SEG_Y)
{
for (IndexType p = 0; p < paths.size(); ++p)
{
seismogramms[p].LoadSegY(paths[p], times);
}
}
else if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x988, %rsp # imm = 0x988
movq %rdx, %r13
movl %esi, %ebx
movq %rdi, %r15
movq 0x40(%rdi), %rax
subq 0x38(%rdi), %rax
leaq 0x18(%rdi), %r14
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rsi
mo... | /v-biryukov[P]segy_csv_converter/seismogram.cpp |
CombinedSeismogramm<float, 2>::AddComponent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ValueGetter<CombinedSeismogramm<float, 2>::Elastic, 2>*) | void CombinedSeismogramm<Scalar, dims>::AddComponent(const std::string& path, ValueGetter<Elastic, dims>* getter)
{
componentInfos.push_back(ComponentInfo(path, getter));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x38, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x7688
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc0b4
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9523
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
... | /v-biryukov[P]segy_csv_converter/seismogram.cpp |
CombinedSeismogramm<float, 3>::Load(SeismoType, 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>>>>) | void CombinedSeismogramm<Scalar, dims>::Load(SeismoType type, std::vector<std::string> paths)
{
seismogramms.resize(componentInfos.size());
if (type == SEG_Y)
{
for (IndexType p = 0; p < paths.size(); ++p)
{
seismogramms[p].LoadSegY(paths[p], times);
}
}
else if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9a8, %rsp # imm = 0x9A8
movq %rdx, %rbp
movl %esi, %ebx
movq %rdi, %r14
movq 0x40(%rdi), %rax
subq 0x38(%rdi), %rax
leaq 0x18(%rdi), %r15
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rsi
mo... | /v-biryukov[P]segy_csv_converter/seismogram.cpp |
CombinedSeismogramm<float, 3>::Save(SeismoType, 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>>>>) | void CombinedSeismogramm<Scalar, dims>::Save(SeismoType type, std::vector<std::string> paths)
{
if (type == SEG_Y)
{
if (paths.size()> seismogramms.size())
{
std::cout << "Too many Seg-Y files to save!" << std::endl;
std::exit(1);
}
for (IndexType i = 0; i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x668, %rsp # imm = 0x668
movq %rdx, (%rsp)
movq %rdi, %r12
cmpl $0x1, %esi
je 0xaabd
testl %esi, %esi
jne 0xb184
movq (%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x5, %rdx
movq 0x20(%r12), %... | /v-biryukov[P]segy_csv_converter/seismogram.cpp |
CombinedSeismogramm<float, 3>::AddValue(float, CombinedSeismogramm<float, 3>::Elastic const&, unsigned int) | void CombinedSeismogramm<Scalar, dims>::AddValue(Scalar time, const Elastic& elastic, IndexType detectorIndex)
{
times.push_back(time);
for (IndexType i = 0; i < componentInfos.size(); ++i)
{
seismogramms[i].AddValue(componentInfos[i].getter->GetValue(elastic), detectorIndex);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movss %xmm0, 0x4(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xb3d3
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xb3e0
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0xbbea
m... | /v-biryukov[P]segy_csv_converter/seismogram.cpp |
glfwExtensionSupported | GLFWAPI int glfwExtensionSupported(const char* extension)
{
_GLFWwindow* window;
_GLFW_REQUIRE_INIT_OR_RETURN(GL_FALSE);
window = _glfwPlatformGetCurrentContext();
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
return GL_FALSE;
}
if (*extension == '\0')
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xf160(%rip), %rax # 0x14558
cmpb $0x0, (%rax)
je 0x54ac
movq %rdi, %rbx
callq 0xcd67
testq %rax, %rax
je 0x54b6
cmpb $0x0, (%rbx)
je 0x54c0
movq %rax, %r15
cmpl $0x3, 0x1c8(%rax)
jl 0x54e3
leaq 0x4(%rsp), %r14
movl $0x821d, %edi ... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/context.c |
glfwTerminate | GLFWAPI void glfwTerminate(void)
{
int i;
if (!_glfwInitialized)
return;
memset(&_glfw.callbacks, 0, sizeof(_glfw.callbacks));
while (_glfw.windowListHead)
glfwDestroyWindow((GLFWwindow*) _glfw.windowListHead);
while (_glfw.cursorListHead)
glfwDestroyCursor((GLFWcursor*) ... | pushq %r15
pushq %r14
pushq %rbx
leaq 0xed6e(%rip), %r14 # 0x14558
cmpb $0x0, (%r14)
je 0x5899
leaq 0xed6d(%rip), %rbx # 0x14568
movq $0x0, 0xd0(%rbx)
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x581e
callq 0x6dcc
jmp 0x5806
callq 0x5de7
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
jne 0x5819
movl 0xc8(%rbx), %esi
t... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/init.c |
glfwInputKey | void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (key >= 0 && key <= GLFW_KEY_LAST)
{
GLboolean repeated = GL_FALSE;
if (action == GLFW_RELEASE && window->keys[key] == GLFW_RELEASE)
return;
if (action == GLFW_PRESS && window->keys[ke... | cmpl $0x15c, %esi # imm = 0x15C
ja 0x5924
movl %esi, %eax
testl %ecx, %ecx
jne 0x58ed
cmpb $0x0, 0x64(%rdi,%rax)
je 0x5933
movl %ecx, %r9d
cmpl $0x1, %ecx
jne 0x5904
cmpb $0x1, 0x64(%rdi,%rax)
movl $0x2, %r9d
cmovnel %ecx, %r9d
testl %ecx, %ecx
je 0x590d
movl %ecx, %r10d
jmp 0x5916
movb $0x3, %r10b
cmpb $0x0... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/input.c |
glfwGetKey | GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (key < 0 || key > GLFW_KEY_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid key");
return GLFW_RELEASE;
}
if (window->keys[key] ... | pushq %rbx
leaq 0xe92a(%rip), %rax # 0x14558
cmpb $0x0, (%rax)
je 0x5c4b
cmpl $0x15d, %esi # imm = 0x15D
jb 0x5c5f
leaq 0x8891(%rip), %rsi # 0xe4d3
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
jmp 0x5c54
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xo... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/input.c |
compareVideoModes | static int compareVideoModes(const void* firstPtr, const void* secondPtr)
{
int firstBPP, secondBPP, firstSize, secondSize;
const GLFWvidmode* first = firstPtr;
const GLFWvidmode* second = secondPtr;
// First sort on color bits per pixel
firstBPP = first->redBits + first->greenBits + first->blueBit... | movl 0xc(%rdi), %eax
addl 0x8(%rdi), %eax
addl 0x10(%rdi), %eax
movl 0xc(%rsi), %ecx
addl 0x8(%rsi), %ecx
addl 0x10(%rsi), %ecx
subl %ecx, %eax
jne 0x66ed
movl 0x4(%rdi), %eax
imull (%rdi), %eax
movl 0x4(%rsi), %ecx
imull (%rsi), %ecx
subl %ecx, %eax
jne 0x66ed
movl 0x14(%rdi), %eax
subl 0x14(%rsi), %eax
retq
| /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/monitor.c |
glfwGetVideoModes | GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!refreshVideoModes(monitor))
return NULL;
*count = monitor->modeCount;
return monitor->modes;
} | pushq %r14
pushq %rbx
pushq %rax
movl $0x0, (%rsi)
leaq 0xdcc3(%rip), %rax # 0x14558
cmpb $0x0, (%rax)
je 0x68b5
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6657
testl %eax, %eax
je 0x68c7
movl 0x18(%rbx), %eax
movl %eax, (%r14)
movq 0x10(%rbx), %rbx
jmp 0x68c9
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/monitor.c |
glfwGetWindowAttrib | GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(0);
switch (attrib)
{
case GLFW_FOCUSED:
return _glfwPlatformWindowFocused(window);
case GLFW_ICONIFIED:
return _glfwPlatf... | pushq %rbx
leaq 0xd20e(%rip), %rax # 0x14558
cmpb $0x0, (%rax)
je 0x7372
leal -0x22001(%rsi), %eax
cmpl $0x8, %eax
ja 0x7386
leaq 0x72cb(%rip), %rcx # 0xe62c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x1c4(%rdi), %ebx
jmp 0x7382
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xor... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/window.c |
glfwPlatformInit | int _glfwPlatformInit(void)
{
#if !defined(X_HAVE_UTF8_STRING)
// HACK: If the current locale is C, apply the environment's locale
// This is done because the C locale breaks wide character input
if (strcmp(setlocale(LC_CTYPE, NULL), "C") == 0)
setlocale(LC_CTYPE, "");
#endif
XInitThreads... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
callq 0x47c0
xorl %edi, %edi
callq 0x43f0
leaq 0xcd91(%rip), %r12 # 0x14568
movq %rax, 0xd8(%r12)
testq %rax, %rax
je 0x7988
movslq 0xe0(%rax), %rcx
movl %ecx, 0xe0(%r12)
movq 0xe8(%rax), %rax
shlq $0x7, %r... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/x11_init.c |
vidmodeFromModeInfo | static GLFWvidmode vidmodeFromModeInfo(const XRRModeInfo* mi,
const XRRCrtcInfo* ci)
{
GLFWvidmode mode;
if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
{
mode.width = mi->height;
mode.height = mi->width;
}
else
{
... | pushq %rbx
movq %rdi, %rbx
movzwl 0x20(%rdx), %eax
cmpl $0x8, %eax
je 0x9261
cmpl $0x2, %eax
jne 0x926c
movl 0xc(%rsi), %eax
movl %eax, (%rbx)
leaq 0x8(%rsi), %rax
jmp 0x9275
movl 0x8(%rsi), %eax
movl %eax, (%rbx)
leaq 0xc(%rsi), %rax
movl (%rax), %eax
movl %eax, 0x4(%rbx)
movl 0x20(%rsi), %eax
xorl %edx, %edx
testl %e... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/x11_monitor.c |
glfwPlatformGetMonitors | _GLFWmonitor** _glfwPlatformGetMonitors(int* count)
{
int i, j, k, found = 0;
_GLFWmonitor** monitors = NULL;
*count = 0;
if (_glfw.x11.randr.available)
{
int screenCount = 0;
XineramaScreenInfo* screens = NULL;
XRRScreenResources* sr = XRRGetScreenResources(_glfw.x11.displ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0x0, (%rdi)
leaq 0xb172(%rip), %r13 # 0x14568
cmpb $0x0, 0x430(%r13)
je 0x9473
movl $0x0, 0x4(%rsp)
movq 0xd8(%r13), %rdi
movq 0xe8(%r13), %rsi
callq 0x4580
movq %rax, %r15
movq 0xd8(%r13), %rdi
movq 0xe8(%r13)... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/x11_monitor.c |
glfwGetWindowProperty | unsigned long _glfwGetWindowProperty(Window window,
Atom property,
Atom type,
unsigned char** value)
{
Atom actualType;
int actualFormat;
unsigned long itemCount, bytesAfter;
XGetWindowPropert... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rax
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0xa960(%rip), %rcx # 0x14568
movq 0xd8(%rcx), %rdi
leaq 0x10(%rsp), %r10
leaq 0x18(%rsp), %r15
leaq 0xc(%rsp), %r11
leaq 0x20(%rsp), %r12
xorl %r14d, %r14d
movabsq $0x7fffffffffffffff, ... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/x11_window.c |
glfwPlatformGetWindowSize | void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height)
{
XWindowAttributes attribs;
XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &attribs);
if (width)
*width = attribs.width;
if (height)
*height = attribs.height;
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x9cb9(%rip), %rax # 0x14568
movq 0xd8(%rax), %rax
movq 0x288(%rdi), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x48e0
testq %r14, %r14
je 0xa8d4
movl 0x8(%rsp), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0xa8df
movl 0xc(%rsp), %eax
movl %... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/x11_window.c |
glfwPlatformApplyCursorMode | void _glfwPlatformApplyCursorMode(_GLFWwindow* window)
{
switch (window->cursorMode)
{
case GLFW_CURSOR_NORMAL:
restoreCursor(window);
break;
case GLFW_CURSOR_HIDDEN:
hideCursor(window);
break;
case GLFW_CURSOR_DISABLED:
disable... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x58(%rdi), %eax
cmpl $0x34003, %eax # imm = 0x34003
je 0xbe36
cmpl $0x34002, %eax # imm = 0x34002
je 0xbe00
cmpl $0x34001, %eax # imm = 0x34001
jne 0xbe79
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbe81
leaq 0x8761(%rip), %... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/x11_window.c |
glfwPlatformCreateStandardCursor | int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape)
{
cursor->x11.handle = XCreateFontCursor(_glfw.x11.display,
translateCursorShape(shape));
if (!cursor->x11.handle)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Fai... | pushq %rbx
movq %rdi, %rbx
leaq 0x866d(%rip), %rax # 0x14568
movq 0xd8(%rax), %rdi
addl $0xfffc9fff, %esi # imm = 0xFFFC9FFF
xorl %eax, %eax
cmpl $0x5, %esi
ja 0xbf1b
movl %esi, %eax
leaq 0x3130(%rip), %rcx # 0xf048
movl (%rcx,%rax,4), %eax
movl %eax, %esi
callq 0x4070
movq %rax, 0x8(%rbx)
movl $0x1, %e... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/x11_window.c |
glfwPlatformSetClipboardString | void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
{
free(_glfw.x11.clipboardString);
_glfw.x11.clipboardString = strdup(string);
XSetSelectionOwner(_glfw.x11.display,
_glfw.x11.CLIPBOARD,
window->x11.handle, CurrentTime);
if (XG... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x85a5(%rip), %r15 # 0x14568
movq 0x110(%r15), %rdi
callq 0x4460
movq %r14, %rdi
callq 0x46e0
movq %rax, 0x110(%r15)
movq 0xd8(%r15), %rdi
movq 0x3f0(%r15), %rsi
movq 0x288(%rbx), %rdx
xorl %ecx, %ecx
callq 0x4720
movq 0xd8(%r15), %rdi
movq 0x3f... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/x11_window.c |
getRawTime | static uint64_t getRawTime(void)
{
#if defined(CLOCK_MONOTONIC)
if (_glfw.posix_time.monotonic)
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (uint64_t) ts.tv_sec * (uint64_t) 1000000000 + (uint64_t) ts.tv_nsec;
}
else
#endif
{
struct timeval tv;
... | pushq %rbx
subq $0x10, %rsp
leaq 0x7931(%rip), %rax # 0x14568
cmpb $0x0, 0x560(%rax)
je 0xcc59
movq %rsp, %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x4180
imulq $0x3b9aca00, (%rbx), %rax # imm = 0x3B9ACA00
jmp 0xcc6d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4230
imulq $0xf4240, (%rbx), %rax # imm ... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/posix_time.c |
glfwCreateContext | int _glfwCreateContext(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
int attribs[40];
GLXFBConfig native = NULL;
GLXContext share = NULL;
if (ctxconfig->share)
share = ctxconfig->share->glx.context;
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rax
testq %rax, %rax
movq %rsi, 0x38(%rsp)
je 0xd1ee
movq 0x2d0(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xd1f7
movq $0x0, 0x20(%rsp)
leaq 0x736a(%rip), %rbp # 0x14568
movq 0xd8(%rbp), ... | /Alfred-Franz[P]OpenGL-Template/external/glfw-3.1.2/src/glx_context.c |
png_get_pixels_per_inch | png_uint_32 PNGAPI
png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr)
{
#ifdef PNG_pHYs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_pHYs) != 0)
{
png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
if (info_pt... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x27cc6
testb $-0x80, 0x8(%rsi)
je 0x27cc6
cmpb $0x1, 0xe8(%rsi)
jne 0x27cc6
movl 0xe0(%rsi), %eax
cmpl 0xe4(%rsi), %eax
jne 0x27cc6
testl %eax, %eax
jns 0x27cc8
xorl %eax, %eax
retq
xorl %eax, %eax
pushq %rax
leaq 0x4(%rsp), %rdi
movl %eax, %esi
movl... | /hunter-packages[P]libpng/pngget.c |
png_get_x_pixels_per_inch | png_uint_32 PNGAPI
png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
info_ptr)
{
#ifdef PNG_pHYs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_pHYs) != 0)
{
png_debug1(1, "in %s retrieval function",
"png_get_x_pixels_per_m... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x27d18
testb $-0x80, 0x8(%rsi)
je 0x27d18
cmpb $0x1, 0xe8(%rsi)
jne 0x27d18
movl 0xe0(%rsi), %esi
testl %esi, %esi
jns 0x27d1a
xorl %eax, %eax
retq
xorl %esi, %esi
pushq %rax
leaq 0x4(%rsp), %rdi
movl $0x7f, %edx
movl $0x1388, %ecx # imm = ... | /hunter-packages[P]libpng/pngget.c |
String::fromBase64(String const&) | String String::fromBase64(const String& data)
{
String result;
usize inlen = data.length();
if (inlen & 0x3)
return String();
result.reserve(data.length());
char* out = (char*)result;
const char* in = (const char*)data;
usize i;
usize j;
unsigned char c;
const unsigned ch... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3ee0
movq -0x10(%rbp), %rdi
callq 0xb130
movq %rax, -0xf8(%rbp)
jmp 0xab9f
movq -0xf8(%rbp), %rax
movq %rax, -... | /craflin[P]libnstd/src/String.cpp |
List<String>::clear() | void clear()
{
for(Item* i = _begin.item, * end = &endItem; i != end; i = i->next)
{
i->~Item();
i->prev = freeItem;
freeItem = i;
}
_begin.item = &endItem;
endItem.prev = 0;
_size = 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x10(%rbp)
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xafdd
movq -0x10(%rbp), %rdi
callq 0x8fe0
movq -0x20(%rbp), %rax
movq 0x50(... | /craflin[P]libnstd/src/../include/nstd/List.hpp |
mbedtls_ripemd160_finish | void mbedtls_ripemd160_finish( mbedtls_ripemd160_context *ctx, unsigned char output[20] )
{
uint32_t last, padn;
uint32_t high, low;
unsigned char msglen[8];
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT32_LE( low, msglen, 0 );
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x1d, %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shll $0x3, %eax
movl %eax, -0x20(%rbp... | /Dragonchang[P]https_client/mbedtls/library/ripemd160.c |
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.